第十一章总结 常用类库
包装类
概念：
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结果：
日期时间类
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结果：
