第十一章总结常用类库

YuRuHaiwuxie

于 2023-05-21 10:18:01 发布

阅读量63

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/YuRuHaiwuxie/article/details/130788566

版权

包装类

概念：

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

Integer类

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

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

例题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个常量

例题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类型时有用的常量和方法。

例题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类还提供了以下常量:

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类还提供了以下常量:
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 的方法。

在 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()方法来实现数字格式化。

例题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类中的常用构造方法

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

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

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

例题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 类提供了标准输入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 类提供的几种常用的方法

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 对象时使用的是 long 型整数，而不是 double 型，因为 double 类型可能会损失精度

例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类默认格式输出:

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的格式化字符

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 类的常用方法

public static Runtime getRuntime() 普通方法用于取得Runtime类的实例
public long freeMemory() 普通方法用于返回Java虚拟机中的空闲内存
public long maxMemory() 返回JVM的最大内存量
public void gc() 运行垃圾回收器。释放空间。
public Process exec(String command) throws IOException 执行本机命令

执行本地命令

本地命令指的是操作系统的命令。例如，在 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类的常用方法

p.start():启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p，不会进行任何清理操作
p.is_alive():如果p仍然运行，返回回True。用来判断进程是否还在运行
p.join([timeout]):主进程等待p终止，timeout是可选的超时时间 Process类常用的属性：
p.name：当前进程实例别名，默认为Proce-N，N为从1开始递增的证书
p.pid:当前进程实例的PID值

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);//输出数组用掉的内存量
				}
			
	}

结果：