第十一章总结-----常用库类-CSDN博客

本文链接：https://blog.csdn.net/2301_76607044/article/details/130787995

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

一，Integer类
Java.lang包中的integer类，byte类，short类和long类，分别将基本数据类型interesting，byte，short和long封装成一个类，由这些类都是number类的子类，区别就是封装不同的数据类型，其包含的方法基本相同。

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

例题11.1【integer类的常用方法】


public class IntegerDemo {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		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);//获取数字的十五进制表示   num表要转换的数，15表转换的进制
		System.out.println("456的二进制表示为："+str2);
		System.out.println("456的二进制表示为："+str3);
		System.out.println("456的二进制表示为："+str4);
		System.out.println("456的二进制表示为："+str5);
	}
 
}

Integer类提供了以下4个常量:
MAXVALUE:表示int类型可取的最大值，即231-1。
MINVALUE:表示int类型可取的最小值，即-23。
SIZE:用来以二进制补码形式表示int值的位数。
TYPE:表示基本类型int的Class 实例。
例题11.2【查看integer类的常量值】


public class GetGon {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		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);
 
	}
 
}

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

例题11.3【double类的常用方法】


public class DoubleDemo {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Double dNum = Double.valueOf("3.14");//创建double对象
		System.out.println("3.14是否为非数字值："+Double.isNaN(dNum.doubleValue()));//判断是否为
		System.out.println("3.14转换为int值为："+dNum.intValue());//intValue直接取整  不四舍五入
		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 类型和String类型的相互转换提供了许多方法,1了处理 boolean 类型时非常有用的其他一些常量和方法。Boolean 类的常用方法如表下：

例题11.4【Boolean类的常用方法】

Boolcan 提供了以下3个常量

TRUE:对应基值ie的 Boolean 对象

FALSEr对应基值lse 的 Boolcan 对象
TYPE:基本类型boolean的Class对象

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

例题11.5【character类的常用方法】


public class UpperOrLower {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		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类提供了大量表示特定字符的常量，例如:
CONNECTOR_PUNCTUATION:返回byte型值，表示 Unicode 规范中的常规类别“Pe"

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

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

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

11.2数字处理
一，数字格式
1，数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字数字格式化操作主要针对的是浮点型数据，包括 double 型和 float 型数据。在 Java 中使用 javatextDecimalFormat格式化数字，本节将着重讲解DecimalFormat类。

2，在Java中，没有格式化的数据遵循以下原则:
口如果数据绝对值大于0.001 并且小于 10000000，使以常规小数形式表示。
口如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。
由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在 Jaw中，可以使用DecimalFormat类进行格式化操作。

3，DecimalFormat类是NumberFormat的一个子类用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一”情况下，可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat 类中applyPattern0方法来实现数字格式化。

4，当格式化数字时，可在DecimalFormat类中使用一些特殊字符构成一个格式化模板，使数字按照定的特殊字符规则进行匹配。表11.7 列举了格式化模板中的特殊字符及其所代表的含义。

例题11.6【DecimalFormat 类的常用方法】

import java.text.DecimalFormat;
public class DecimalFormatSimpleDemo {
	static public void SimgleFormat(String pattern,double value) {
		DecimalFormat myFormat = new DecimalFormat(pattern);
		String output = myFormat.format(value);//将数字进行格式化
		System.out.println(value+""+pattern+""+output);
	}
	
	static public void UseApplyPatternMethodFormat(String pattern,double value) {
		DecimalFormat myFormat = new DecimalFormat();
		myFormat.applyPattern(pattern);//调用applypattern方法设置格式化模板
		System.out.println(value+""+pattern+""+myFormat.format(value));
	}
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		SimgleFormat("###,###,###",123456.789);//调用静态simgleformat方法
		SimgleFormat("00000000.###kg",123456.789);//在数字后加上单位
		SimgleFormat("000000.000",123.78);
		UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分数形式
		UseApplyPatternMethodFormat("###.##",123456.789);//将小数后格式化为两位
		UseApplyPatternMethodFormat("0,00\u2030",0.789);//将数字转换为千分数形式
	}
 
}

在DecimalFormat类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方法对数字行格式化设置。例如：

DecimalFormat myFormat = newDecimalFormat();//实例化decimalFormat类对象
myFormat.setGroupingSize(2);//设置将数字分组的大小
myFormat.setGroupingUsed(false）；//设置是否支持分组

在项目中创建 DecimalMethod类，在类的主方法中调用setGroupingSize0与 setGroupingUsed0方法实现数字的分组：


import java.text.DecimalFormat;
public class DecimalMethod {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		DecimalFormat myFormat = new DecimalFormat();
		myFormat.setGroupingSize(2);//将数字分组为2
		String output = myFormat.format(123456.789);
		System.out.println("将数字以每两个数字分组"+output);
		myFormat.setGroupingUsed(false);//设置不允许分组
		String output2 = myFormat.format(123456.789);
		System.out.println("不允许数字分组"+output2);
		
		
	}
 
}

二，Math类

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

Math.数学方法

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


Math.PI
Math.E


Math 类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。
 
1.三角函数方法
Math类中包含的三角函数方法如下:
 publicstatic 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):将弧度转换为角度。
 
例题11.7【]在Java代码中进行三角函数运算】

2.指数函数方法
Math类中与指数相关的函数方法如下：
publicstatic double exp(doublea):用于获取e的a次方，即取e^2
publicstatic double log(doublea):用于取自然对数，即取Ina的值

publicstaticdoublelog10(doublea):用于取底数为10的a的对数。

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

例题11.8【在Java代码中进行指数函数运算】


public class ExponentFunction {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("e的平方值："+Math.exp(2));//取e的2 次方
		System.out.println("以e为底2的对数值”"+Math.log(2));//取以e 为底2的对数
		System.out.println("以e为底2的对数值”"+Math.log(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在Mah类中添加了数字取整方法。Mahx
中主要包括以下几种取整方法:
public static double ceil(double a): 返回大于等于参数的最小整数
public static double floor(double a): 返回小于等于参数的最大整数
public static double rint(double a): 返与参数最接近的整数，如果存在两个同样接近的整数.
则结果取偶数。
public static int round(float a): 将参数加上05 后返与参数最近的整数

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

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


public class IntFunction {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  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));
  //返回与参数最接近的整数
  System.out.println("使用round()方法取整："+Math.round(3.4f));
  //将参数加上0.5后返回最接近的整数
  System.out.println("使用round()方法取整："+Math.round(2.5));
  //将参数加上0.5后返回最接近的整数，并强制转换为长整型
  
  
 }
 
}

4.取最大值、最小值、绝对值函数方法
在程序中最常用的方法就是取最大值、最小值、绝对值等，Math 类中包括的操作方法如下:
public static double max(double adouble b):取a与b之间的最大值。
publicstaticintmin(intaint b):取a与b之间的最小值，参数为整型。
publicstaticlongmin(longa,longb):取a与b之间的最小值，参数为长整型。
public static float min(float a,float b): 取a与b之间的最小值，参数为单精度浮点型。
public static double min(double a,double b): 取a与b之间的最小值，参数为双精度浮点型
public staticintabs(inta):返回整型参数的绝对值。
public static longabs(longa):返回长整型参数的绝对值。
public static float abs(float a):返回单精度浮点型参数的绝对值。
public static double abs(doublea):返回双精度浮点型参数的绝对值。

例题11.9【取最大值、最小值、绝对值的方法】

public class AnyFunction {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println("4和8较大值："+Math.max(4, 8));
  //取两个参数的最大值
  System.out.println("4.4和4较小值："+Math.min(4.4, 4));
  //取两个参数的最小值
  System.out.println("-7的绝对值："+Math.abs(-7));
  //取参数的绝对值
 }
 
}

三，Random类

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

Random r = new Random():

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

Random r = new Random(seedValue)

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

在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【获取不同的取值范围，不同类型的随机数】

import java.util.Random;
public class RandomDemo {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  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类
1，在 BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数大公约数以及判断是否为质数等操作。

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

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

Biglnteger twolnstance = new Biglnteger("2");

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

public BigInteger subtract(BigInteger va): 做减法运算

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

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

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

public BigInteger]] divideAndRemainder(BigInteger val): 用数组返回余数和商，结果数组中lt爱险法的商一个值为商，第二个值为余数。

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

public BigInteger negate0: 取相反数。

public BigInteger shifLef(int n): 将数字左移n位，如果n为负数，做右移操作

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

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

public BigInteger or(Biglnteger 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类进行数学运算】

import java.math.BigInteger;
public class BigIntegerDemo {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //第一个大数字
  BigInteger b1 = new BigInteger("987654321987654321");
  //第二个大数字
  BigInteger b2 = new BigInteger("123456789123456789");
  //加法运算
  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]);
  //2次方运算
  System.out.println("做2次方操作："+b1.pow(2));
  //相反数运算
  System.out.println("取相反数操作："+b1.negate());
 }
 
}

五，BigDecimal类

BirDecimal 类支持任何精度的定点数，可以用它来精响计货值在BigDecimal类中，常用的两个构造方法如下：

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

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

例题11.13【使用BigDecimal类进行数学运算】

import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalDemo {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //第一个大小数
  BigDecimal b1 = new BigDecimal("0.00987654321987654321");
  //第二个大小数
  BigDecimal b2 = new BigDecimal("0.00123456789123456789");
  //加法运算
  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));
  
  
  
 }
 
}

11.3 System类

1.Svstem类是JDK 中提供的系统类，该类是用 fial 修饰的，所以不允许被承。System 类提供了很多系统层面的操作方法，并且这些方法全部都是静态的。System类提供的较常用方法如表 11.11所示。

一，控制台输出字符

System类提供了标准输入、标准输出和错误输出流，也就是说，System 类提供了3个静态对象:in、out和err。本书中的代码多次使用了这些对象，最常见的就是 out 对象。

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

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

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

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

3.print0方法与println0方法输出的对比效果如表11.12所示

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

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

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

二，计时

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

例题11.14【查看执行一万次字符串拼接所消耗的时间】

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

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

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

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

3.Scanner类的几个常用方法

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

Scanner sc = new Scanner(System.in);

例题11.15【猜数字游戏】


import java.util.Random;
import java.util.Scanner;
public class ScannerDemo {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		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 类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，其构造方法及其说明如表11.14所示。

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

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

上述代码中的System类的currentTimeMillis0方法主要用来获取当前系统时间距标准基准时间的毫秒数。另外，这里需要注意的是，创建 Date 对象时使用的是 long 型整数，而不是 double 型，这主要是因为 double类型可能会损失精度。

2.Date 类的常用方法及其说明如表 11.15所示。

例题11.16【获取当前的日期和时间】


import java.util.Date;
public class DateDemo {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Date date = new Date();//创建现在的日期
		//Date date = new Date(1234567891223L);//创建指定时间后加 L
		long value = date.getTime();//获得毫秒数
		System.out.println("日期:" + date);
		System.out.println("到现在所经历的毫秒数为:"+value);
		}
 
}

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

SHORT:完全为数字，如12.13.52或3:30pm。
MEDIUM:较长，如Jan 12,1952。
LONG:更长，如January12,1952或3:30:32pm。
FULL:完全指定，如Tuesday、April12、1952AD或3:3042pm PST

2.可以使用其静态方法getDateInstance(进行创建，语法如下:

DateFormat df = DateFormat.getDatelnstance();

3.DateFormat类的常用方法及其说明如表11.16所示

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

5.SimpleDateFormat 类提供了19个格式化字符，可以让开发者随意编写日期格式，这19个格式化字符如表11.17所示。

6.一些常用的日期时间格式如表 11.18所示

例题11.17【以中文形式打印当前的日期和时间】

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatDemo {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		DateFormat df = new SimpleDateFormat("yyyy年MM月dd日EEEEHH时mm分ss秒");
		System.out.print("各位观众大家好，现在是");
		System.out.print(df.format(new Date()));
		System.out.println(",欢迎收看新闻.");
	}
 
}

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

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

Calendar rightNow = Calendar.getlnstance();

3.Calendar类提供的常用字段及其说明如表11.19所示。

4.Calendar类提供的常用方法及其说明如表 11.20所示。

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

例题11.18【今天离中华人民共和国成立100周年差多少天】

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
 
public class CountDown {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		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* 6024);
		System.out.println("距离2049年10月1日还有"+day+"天!");
		
	}
 
}

11.6Runtime类
1.Runtime类是 JDK 提供的运行时类，该类为Ja 提供了与当前运行环境相连接的一个通Java程可以利用设头提的超行环填执行一些简单的操作。Runtime 类不能使用 new 关键字创建看例，只能通过RuntimegetRuntime0方法获取实例。

2.Runtime类的常用方决知表1121所示，本节将重点讲解利用 Runtime 类执行本地命令和查看虚拟机所占内存这两个操作。

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

Process exec(String command)
Process exec(Stringl cmdarray)

2.Proces 类的常用方法如表 11.22 所示，开发可以使用 getlnputStream0方法获取进返回的信

例题11.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) {
		// TODO 自动生成的方法存根
		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.查看内存
1.Runtime类可以通过freeMemory0方法查看当前Java虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张

例题11.20【监控虚拟机内存使用情况】

public class MemoryDamo {
 
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		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("数组用掉的内存字节数:"+(before- after));//输出数组用掉的内存量
	}
 
}