第11章：常用类库

哪错了？

已于 2023-05-20 00:58:49 修改

阅读量154

点赞数 1

文章标签： java jvm c++

于 2023-05-20 00:37:28 首次发布

本文链接：https://blog.csdn.net/m0_75052101/article/details/130629791

版权

包装类

概念：

Java是一种面向对象语言，但Java并不能定义基本数据类型的对象，为了能够将基本收据类型视为对象进行处理，Java提出了包装类的概念，这样可以把这些基本数据类型转换为对象进行处理。

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

Integer类

在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段

该类方法还提供了多个方法，能够在int和String类型之间互相转换

Integer类的常用方法
方法	描述
valueOf(String str)
parseInt(String str)
toString()
toBinaryString(int i)
toHexString(int i)
toOctalString(int i)
equals（Object IntegerObj)
intValue()
shortValue()
byteValue()
compareTo(Integer anotherInteger)

例题11.1：Integer类的常用方法

package lit;

public class IntegerDemo {

	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));
		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);
	}

}

除了方法Integer类还提供了以下4个常量

MAX_VALUE

表示int类型可取的最大值

MIN__VALUE

表示int类型可取的最小值

SIZE

表示int的二进制位数

例题11.2：查看Integer类的常量值

package lit;

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);

	}

}

Double类

double类和float类是对double、float基本类型的封装，它们都是 Number类的子类，

所以常用方法基本相同。

Double类在对象中包装一个基本类型为double的值，每个Double类的对象都包含一个double类型的字段，此外，该类还提供多个方法，可以将double类型转换为为String类型，将String类型转换为double类型，也提供了其他一些处理double类型时有用的常量和方法。

Double 类的常用方法
方法	功能猫述
valueOf(String str)	近回保存用参数字符串表示的double值的 Double 对象
parseDouble(String s)	返回一个的 double值，该值被初始化为用指定String表示的值，这与 Double 类的value（）方法一样
doubleValuc()	以double 形式返回此Double对象
isNaN()	如果此double 值是非数字(NaN）值，则返回true:否则返回 false
intValue()	以int形式返回 double 值
byteValue()	以byte 形式返回 Double 对象值 (通过强制转换)
longValue()	以 long 形式返回此 double 的值 (通过强制转换为 long 类型)
compareTo(Double d)	对两个 Double对象进行数值比较。如果两个值相等，则返回0;如果调用对象的数值小于d的值，则返回负值;如果调用对象的数值大于 d 的值，则返回正值
equals(Object obj)	将此对象与指定的对象相比较
toString()	返回此 Double 对象的字符串表示形式
toHexString(double d)	返回 double 参数的十六进制字符串表示形式

例题11.3：Double类的常用方法

package lit;

public class DoubleDemo {

	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());//转换为int型
		//判断大小
		System.out.println("值为3.14的Double对象与3.14的比较结果："+dNum.equals(3.14));
		//转换为十六进制
		System.out.println("3.14的十六进制表示为值："+Double.toHexString(dNum));

	}

}

Double 类还提供了以下常量:

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

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

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

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

Boolean 类

Boolean类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。

此类还为 boolean 类型和 Sring 类型的相互转换提供了许多方法，并提供了处理 boolean 类型时非

常有用的其他一些常量和方法。

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

Boolean类还提供了以下常量:

TRUE:对应基值true的Boolean对象

FALSE：对应基值false的Boolean对象

TYPE：基值booleand的Class对象

例题11.4：Boolean 类的常用方法

package lit;

public class BooleanDemo {

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

}

Character类

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

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

Character类还提供了以下常量:

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

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

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

例题11.5：Character类的常用方法

package lit;

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(mychar1));
			}
		

	}

}

Number类

对于数值型的包装类，它们有一个共同的父类一Numbr类，该类是一个抽象类，它是 Byte、Integer、Short、 Long、Flat 和 Double 类的父类，其子类必须提供将表示的数值转换为 byte、int、short、long、float 和 double 的方法。

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

在 Number 类的所有子类中都包含以上这儿种方法。

数字处理

Java 语言中，提供了一个执行数学基本运算的 Math 类，该类包括常用的数学运算方法，如三角函数方法等一些常用数学函数方法。除此之外还提供了一些常用的数学常量。

在实际开发中，随机数的使用是很普遍的，所以要掌握生成随机数的操作。

在 Java 中主要提供了两种生成随机数的方式

调用 Math 类的random()方法生成随机数

调用 Random类生成各种数据类型的随机数

Java中，还提供了大数字的操作类，即 java.math,BigInteger 类与javamathBigDecimal类这两个类

用于高精度计算，其中 BigInteger 类是针对大整数的处理类，而 BigDecimal 类则是针对大小数的

数字格式化

数字格式化在解决实际问题时应用非常普遍，如表示超市的商品价格，需要保留两位小数。

主要针对的是浮点型数据，包括double和float数据，

使用Java.text.DecimalFormat

java中没有数据格式化的数据遵行以下原则

如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示

如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示

DecimalFormat类是NumberFormat 的一个子类，用于格式化十进制数字。

可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat类中的applyPattern()方法来实现数字格式化。

DecimalFormat 类中的特殊字符及其说明
字符	说明
0	代表阿拉伯数字，使用特殊字符“0”表示数字的一位阿拉伯数字，如果该位不存在数字，则显示0
#	代表阿拉伯的数字，使用特殊字符“#”表示数字的一位阿拉伯数字，如果该位存在数字，则显示字符，如果该位不存在数字，则不显示
.	小数分隔符或货币小数分隔符
-	负号
,	分组分隔符
E	分隔科学记数法中的尾数和指数
%	放置在数字的前缀或后缀，将数字乘以100显示为百分数
\u2030	放置在数字的前缀或后缀，将数字乘以1000显示为百分数
\u00A4	放置在数字的前缓或后缀，作为货币记号
‘	单引号，当上述特殊字符出现在数字中时，应为特殊符号添加单引号，系统会将此符号视为普通符号处理

例题11.6：DecimalFormat类的常用方法

package lit;
import java.text.DecimalFormat;//导入类
public class DecimalFormatSimpleDemo {
	//使用实例化对象设置格式化模式
	static public void SimgleFormat(String pattern,double value) {
		DecimalFormat myFormat=new DecimalFormat(pattern);//实例化DecimalFormat对象
		String output =myFormat.format(value);//将数字格式化
		System.out.println(value+""+pattern+""+output);
}
	//使用applyPattern()方法对数字进行格式化
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);//调用静态StringFormat()方法
	SimgleFormat("00000000.###kg",123456.789);//加上单位
	
	SimgleFormat("000000.000",123.78);
	
	UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分比形式
	UseApplyPatternMethodFormat("###.##",123456.789);//将小数点后格式化为两位
	UseApplyPatternMethodFormat("0.00\u2030",0.789);//将数字转换为千分数形式
		

	}

}

SimgleFormat()方法是在实例化 Decimalformat 对象时设置数字格式化模板

UseApplyPatternMethodPormal0)方法是在实例化 DecimalFormat 对象后调用spplype方法设置数宇格式化模板。
在 DecimalFormat 类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方注对数行格式化设置。例如;

myFormat2.setGroupingSize(3);//设置几个数进行初始化

myFormat2.setGroupingUsed(true);//setGroupingUsed的开关

String my2=myFormat2.format(7857478);//传入要格式化的数

Math类

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

Math.函数方法

三角函数方法

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

public static double cos(double a):返回角的三角余弦
public static double tan(double a): 返回角的三角正切。
public static double asin(double a):返回一个值的反正弦
public static double acos(double a): 返回一个值的反余弦
public static double atan(double a): 返回一个值的反正切。
public static double toRadians(double angdeg): 将角度转换为弧度
public static double toDegrees(double angrad): 将弧度转换为角度。

以上每个方法的参数和返回值都是 double型的。将这些方法的参数的值设置为 double 型是有一定道理的，参数以弧度代替角度实现

角度与弧度的转换通常是不精确的。

例题11.7：在Java代码中进行三角函数运算

package lit;

public class TrigonometricFunction {

	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°的正切
		//取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的角度
		

	}

}

指数函数方法

pbhe static double exp(double a): 用于获取e的a次方，即取
publie static double log(double a): 用于取自然对数，即取lna的值。
public staric double logl0(double a):用于取底数为10的a的对数

public static double sqrt(double a):用于取a的平方根，其中a的值不能为负值
public static double cbrt(double a):用于取a的立方根。
public static double pow(double a，double b):用于取a的b次方。

例题11.8：在Java中使用指数函数进行运算

package lit;

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));//取以e为底2对数
		System.out.println("以10为底2的对数值："+Math.log10(2));//取以10为底2的对数值
		System.out.println("4的平方根值："+Math.sqrt(4));//取平方根
		System.out.println("8的立方值："+Math.cbrt(8));//取8的立方
		System.out.println("2的2次方值："+Math.pow(2, 2));//取2的2次方
		

	}

}

取整函数方法

public static double ceil(double a): 返回大于等于参数的最小整数。
public static double floor(double a): 返回小于等于参数的最大整数。
public static double rint(double a): 返回与参数最接近的整数，如果同样接近，取偶数。
public static int round(float a): 将参数加上0.5 后返回与参数最近的整数。public static long round(double a): 将参数加上0.5后返回与参数最近的整数，然后强制转换为长整型。

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

package lit;

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

}

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

publie static double max(double a,double b）: 取a与b之间的最大值
publie static int min(int a,int b): 取a 与b之间的最小值，参数为整型
publie static long min(long a,long b): 取 a与b之间的最小值，参数为长整型
publie static flat min(float a,float b): 取a 与b之间的最小值，参数为单精度浮点型

publie static double min(double a.double b): 取a 与b之间的最小值，参数为双精度浮点型
publie static int abs(int a): 返回整型参数的绝对值。
public static long abs(long a): 返回长整型参数的绝对值。
public static float abs(floata): 返回单精度浮点型参数的绝对值。

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

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

package lit;

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("-的绝对值："+Math.abs(-7));//取绝对值

	}

}

Random类

Random 类是JDK 中的随机数生成器类

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

Random r=new Random();

因为每时每刻的时间不可能相同，所以产生的随机数不同。但是如果运行速度太快，也会产生两

个运行结果相同的随机数。

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

Random r = new Random(seedValue);

Random的常用方法

public int nextInt():返回一个随机整数。
public int nextInt(int n): 返回大于等于0 且小于n 的随机整数
public long nextLong(): 返回一个随机长整型值。

public boolean nextBoolean(): 返回一个随机布尔型值。
public float nextFloat(): 返回一个随机单精度浮点型值。
public double nextDouble(): 返回一个随机双精度浮点型值。
public double nextGaussian(): 返回一个概率密度为高斯分布的双精度浮点型值。

例11.11:获取不同取值范围、不同类型的随机数

package lit;

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());
		
		

	}

}

BigInteger 类

Integer 类是 int 的包装类int 的最大值为 $2^{31}-1$ ，如果要计算更大的数字，使用 Integer 类就无法

实现了

所以 Java 中提供了BigInteger 类来处理更大的数字使用 BigInteger 类，可以实例化一BigInteger

对象，并自动调用相应的构造函数

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

BigInteger twolnstance = new Biginteger("2")

BigInteger类中常用的几种运算方法:

public BigInteger add(BigInteger val): 做加法运算。
public BigInteger subtract(BigInteger val): 做减法运算
public BigInteger multiply(BigInteger val): 做乘法运算
public BigInteger divide(BigInteger val): 做除法运算。
public BigInteger remainder(BigInteger val): 做取余操作
public BigIntegerl [ ]divideAndRemainder(Biglnteger val): 用数组返回余数和商，结果数组中第一
个值为商，第二个值为余数。
public BigInteger pow(int exponent): 进行取参数的exponent 次方操作。
public BigInteger negate(): 取相反数。
public BigInteger shiftLef(int n): 将数字左移n位，如果n 为负数，做右移操作
public BigInteger shiftRight(int n): 将数字右移n 位，如果n为负数，做左移操作
public BigInteger and(BigInteger val): 做与操作。
public BigInteger or(BigInteger val): 做或操作。
public int compareTo(BigInteger val): 做数字比较操作。
public boolean equals(Object x): 当参数x是 BigInteger 类型的数字并且数值与对象实例的数值相等时，返回 true。
public BigInteger min(BigInteger val): 返回较小的数值。
public BigInteger max(BigInteger val): 返回较大的数值。

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

package lit;

import java.math.BigInteger;

public class BigIntgerDemo {

	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());//相反数运算
		

	}

}

divideAndRemainder()方法做除法操作，以数组的形式返回,。第一个值为做除法的商，第二个值为做除法的余数

BigDecimal类

BigDecimal类和 Biglnteger 类都能实现大数字的运算，

不同的是BigDecimal类加入了小数的概念，一般的float和double 型数据只可以用来做科学计算工

程计算，但由于在商业计算中要求数字精度比较高，所以要用到BigDecimal类。

BigDecimal类支持任何精度的定点数，可以用它来精确计算低值。

BigDecimal类中的常用构造方法

BigDecimal类中的常用构造方法
构造方法	功能说明
BigDecimal(double val)	实例化时将双精度浮点型转换为BigDecimal类型
BigDecimal(String val)	实例化时将字符串形式转换为BigDecimal类型

BieDecimal 类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运

算中除法是最复杂的，因为在除不尽的情况下商小数点后的末位的处理是需要考虑的

BigDecimal 类的加、减、乘、除的方法
方法	功能说明
add(BigDecimal augend)	做加法操作
subtract(BigDecimal subtrahend)	做减法操作
multiply(BigDecimal multiplicand)	做乘法操作
divide(BigDecimal divisor,int，scale，RoundingModeroundingMode)	做除法操作，方法中3 个参数分别代表除数、商的小数点后的位数、近似处理模式

divide()方法的多种处理模式

BigDecimal 类中的 divide()方法的多种处理模式
模式	方法
RoundingMode.UP	商的最后一位如果大于 0，则向前进位，正负数都如此
RoundingMode.DOWN	商的最后一位无论是什么数字都省略
RoundingMode.CEILING	商如果是正数，按照 UP 模式处理; 如果是负数，按照 DOWN 模式处理。这种模式的处理都会使近似值大于等于实际值
RoundingMode.FLOOR	与 CEILING 模式相反，商如果是正数，按照 DOWN 模式处理;商如果是负数，则按照 UP 模式处理。这种模式的处理都会使近似值小于等于实际值
RoundingMode.HALF_DOWN	对商进行四舍五入操作，如果商最后一位小于等于 5，则做舍弃操作;如果最后一位大于 5，则做进位操作
RoundingMode.HALF_UP	对商进行四舍五入操作，如果商的最后一位小于 5 则舍弃;如果大于等于 5，进行进位操作
RoundingMode.HALF_EVEN	如果商的倒数第二位为奇数，则按照 HALF_ UP 模式处理;如果为偶数，则按照HALF_ DOWN模式处理

例题11.13：使用BigDecimalDemo类进行数字运算

package lit;

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));//乘法运算
				System.out.println("两个数字相除结果："+b1.divide(b2));
				//除法运算,商保留小数点后9位，并将结果进行四舍五入操作
				System.out.println("两个数字相除，保留小数点后9位："+b1.divide(b2,9,RoundingMode.HALF_UP));


	}

}

System类

System 类是 JDK 中提供的系统类，该类是用 final 修饰的，所以不允许被继。

System 类提供的方法全部都是静态的

System 类提供的常用方法
方法	功能描述
currentTimeMillis()	返回以毫秒为单位的当前时间
exit(int status)	通过启动虚拟机的关闭序列，终止当前正在运行的Java 虚拟机。此方法从不正常返回。可以将变量作为一个状态码。根据惯例，非零的状态码表示非正常终止；0 表示正常终止
Map<String,String> getenv()	返回一个不能修改的当前系统环境的字符串映射视图
getenv(String name)	获取指定的环境变量值
getProperties()	确定当前的系统属性
getProperty(String key)	获取用指定键描述的系统属性
setIn(InputStream in)	重新分配“标准”输入流

控制台输出字符

System 类提供了标准输入in、标准输出out和错误输出流err

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

System.out.print();

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

println()方法在 print后面加上了“In”后缀 (就是 line 的简写)

System.out.println();

Java 输出换行的方法有以下两种:
System.out.print("\n"); //利用换行符n 实现换行

System.out.println(); //空参数即可实现换行

计时

Sywem.curemTimeMillis()方法可以获取现在的毫秒数。

虽然 Date 日期也有类似的方法，但代码会比 Systcm 类多，

所以 System.currentTimeMillis()方法是为获取当前毫秒最常用的方法。

该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。

11.14:查看执行一万次字符串拼接所消耗的时间

package lit;

public class SystemTimeDemo {

	public static void main(String[] args) {
		long start=System.currentTimeMillis();//获取程序开始的时间
		String str=null;
		for(int i=0;i<10000;i++) {//循环次数
			str+=i;
			
		}
		long end=System.currentTimeMillis();//获取程序结束时间
		System.out.println("循环用时："+(end-start)+"毫秒");//输出
	}

}

Scanner类

Java 从控制台中读出用户输入的值，用到的是一个叫 Scanner 的类来实现的。

Scanner 英文直译就是扫描仪，它的用途就是数字化信息流转为人类可识别的文字。

System.out 就表示向控制台输出

System.in 就表示从控制台输入

让 Sanner 扫描 System.in 就可以获取用户输入的值了使用 Scanner 类首先要引入该类，语法如下：

import java.util.Scanner；

Scanner 类提供的几种常用的方法

Scanner 类的几个常用方法
方法名	返回类型	功能说明	方法名	返回类型	功能说明
next()	String	查找并返回此扫描器获取的下一个完整标记	nextInt()	int	扫描一个值返回int类型
nextBoolean()	boolean	扫描一个布尔值标记并返回	nextLine()	String	扫描一个值返回String类型
nextBtye()	byte	扫描一个值返回 byte类型	nextLong()	long	扫描一个值返回long类型
nextDouble()	double	扫描一个值返回double类型	nextShort()	short	扫描一个值返回 short类型
nextFloat()	float	扫描一个值返回foat类型	close()	void	关闭此扫描器

nextLine()方法扫描的内容是从第一个字符开始到换行符为止

而 next()、nextInt()等方法扫描的内容是从第一个字符开始到这段完整内容结束。

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

Scanner sc = new Scanner(System.in);

System.in 表示控制台输入流，

例11.15:猜数字游戏

package lit;

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=0;//记录用户输入的值
		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();//关闭扫描器，不然很占内存
	}

}

日期时间类

Date类

Date 类用于表示日期时间，，使用该类表示时间需要使用其构造方法创建对象

Date 类的构造方法及其说明
构造方法	说明
Date()	分配 Date 对象并初始化此对象，以表示分配它的时间(精确到毫秒)
Date(long date)	分配 Date 对象并初始化此对象，以表示自标准基准时间(即 1970 年 1月1 日 00:00:00 GMT)起经过指定毫秒数 date 后的时间

创建 Date 对象时使用的是 long 型整数，而不是 double 型，因为 double 类型可能会损失精度

Date 类的常用方法及其说明
方法	说明
after(Date when)	测试当前日期是否在指定的日期之后
before(Date when)	测试当前日期是否在指定的日期之前
getTime()	获得现在所经过的毫秒数
setTime(long time)	设置当前 Date对象所表示的日期时间值,该值用以表示1970年1月1日 00:00:00 GMT 以后time毫秒的时间点

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

package lit;

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);
	}

}

11.5.2 日期时间格式化

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化

DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期

时间Formatter，格式化风格主要包括 SHORT、MEDIUM、LONG 和FULL4种:

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

MEDIUM:较长，如 Jan 12,1952。

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

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

另外，使用 DateFormat 类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期,首

先需要创建 DateFormat 类的一个对象，由于它是抽象类，因此可以使用其静态方

getDateInstance()进行创建，语法如下:

DateFormat df = DateFormat.getDatelnstance();

使用 getDateInstance()方法获取的是所在国家或地区的标准日期格式。另外，DateFormat 类还提

供了一些其他静态方法。例如，使用 getTimeInstance()方法可获取所在国家或地区的时间格式，

使用getDateTimeInstance()方法可获取日期和时间格式。

DateFormat 类的常用方法及其说明
方法	说明
format(Date date)	将一个 Date 对象实例格式化为日期/时间字符串
getCalendar()	获取与此日期/时间格式器关联的日历
getDateInstance()	获取日期格式器，该格式器具有默认语言环境的默认格式化风格
getDateTimeInstance()	获取日期/时间格式器，该格式器具有默认语言环境的默认格式化风格
getInstance()	获取为日期和时间使用SHORT风格的默认日期/时间格式器
getTimeInstance()	获取时间格式器，该格式器具有默认语言环境的默认格式化风格
parse(String source)	将字符串解析成一个日期，并返回这个日期的Date 对象

例如，将当前日期按照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.println(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

SimpleDateFormat的格式化字符

SimpleDateFormat的格式化字符
字母	日期或时间	类型	示例
G	Era标志符	Text	AD
y	年	Year	1996;96
M	年中的月份	Month	July: Jul: 07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Number	Tuesday; Tue
a	Am/ pm标记	Text	PM
H	一天中的小时数(0~23)	Text	0
h	am/pm中的小时数(1~12)	Number	12
k	一天中的小时数(1~24)	Number	24
K	am/pm中的小时数(0~11)	Number	0
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978
z	时区	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	时区	RFC 822 time zone	-800

Calendar 类提供的常用方法

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

package lit;

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);
		//将当前时间转换为毫秒数
		long time1=date.getTime();
		//使用默认时区和语言环境获得一个日历
		Calendar calendar=Calendar.getInstance();
		//设置日历calendar中的年月日，因为月份是从0开始计算的，所以这里
		calendar.set(2049,10-1,1);
		//计算1970年1月1日至2049年10月1日所经过的毫秒数
		long time2=calendar.getTimeInMillis();
		//计算差值
		long day=(time2-time1)/(1000*60*60*24);
		//输出
		System.out.println("距离2049年10月1日还有"+day+"天！");
		





	}

}

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

c.set(CalendarDAY_OF_MONTH,0)获取的是上个月的最后一天，所以调用前需要将月份往后加一个月。
Calendar.MONTH的第一个月是使用0记录的，所以在获得月份数字后要加1。年和日是从1开始记录的，不需要加 1。
Calendar.DAY OF WEEK 的第一天是周日，周一是第二天，周六是最后一天

Runtime类

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

Runtime 类的常用方法

执行本地命令

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

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

Process exec(String command)

Process exec(Stringl cmdarray)

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

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

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

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

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

Runtime.getRuntime().exec(command);

Process类的常用方法

package lit;

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;//创建空字符
			while((str=br.readLine())!=null) {//如果字符流中可以获取非空内容
				System.out.println(str);//打印
			}
			
	}catch(IOException e) {
			e.printStackTrace();
		}

	}
}

查看内存

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

例题11.20：监控虚拟机内存的使用情况

package lit;

public class MemoryDemo {

	public static void main(String[] args) {
	
				Runtime r=Runtime.getRuntime();//获取本地Runtime对象
				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("数组用掉的内存字节数："+after);//输出数组用掉的内存量
				}
			
	}

哪错了？

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第11章：常用类库

Double类在对象中包装一个基本类型为double的值，每个Double类的对象都包含一个double类型的字段，此外，该类还提供多个方法，可以将double类型转换为为String类型，将String类型转换为double类型，也提供了其他一些处理double类型时有用的常量和方法。Java是一种面向对象语言，但Java并不能定义基本数据类型的对象，为了能够将基本收据类型视为对象进行处理，Java提出了包装类的概念，这样可以把这些基本数据类型转换为对象进行处理。除此之外还提供了一些常用的数学常量。
复制链接

扫一扫