第11总结-CSDN博客

本文链接：https://blog.csdn.net/xy164914506/article/details/130787407

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

11.1.1 Integer类

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

常用方法如下表：

例题11.1

 
public class IntergerDaemo {
 
	public static void main(String[] args) {
		
		// TODO Auto-generated method stub
		int num = Integer.parseInt("456");                  //将字符串转换为int类型
		Integer iNum = Integer.valueOf("456");           //创建一个intefer对象
		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);
	}
}
//例题11.1

Integer类提供了以下4个常量:
☑MAX VALUE:表示 int 类型可取的最大值,即³¹。
2³¹−1。
☑MIN VALUE:表示 int 类型可取的最小值,即³¹。
−2³¹。
☑ SIZE：用来以二进制补码形式表示int值的位数。
☑ TYPE:表示基本类型int 的Class实例。

例题11.2

 
public class GetCon {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int maxint = Integer.MAX_VALUE;               //获取Integer类的常量值
  int minint = Integer.MIN_VALUE;
  int intsize = Integer.SIZE;
  System.out.println("int数据与Interger对象的比较："+maxint);      //将常量值输出
  System.out.println("int数据与Interger对象的比较："+minint);
  System.out.println("int数据与Interger对象的比较："+intsize);
 }
 
}
//例题11.2

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

例题11.3

 
public class DoubleDemo {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  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));
  
 }
 
}
//例题11.3

Double类主要提供了以下常量：
☑MAX EXPONENT:返回 int 值,表示有限 double 变量可能具有的最大指数。
☑MIN EXPONENT:返回 int 值,表示标准化 double 变量可能具有的最小指数。
☑NEGATIVE INFINITY:返回 double 值,表示保存 double 类型的负无穷大值的常量。
☑POSITIVE INFINITY:返回 double 值,表示保存 double 类型的正无穷大值的常量。

11.1.3 Boolean类

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

 
public class BooleanDemo {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Boolean b1 =Boolean.valueOf("true"); //创建Boolean对象
  Boolean b2 =Boolean.valueOf("ok");
  System.out.println("b1:"+b1.booleanValue());
  System.out.println("b2:"+b2.booleanValue());
 }
 
}
//例11.4

Boolean提供了以下3个常量:
☑ TRUE:对应基值true的Boolean 对象。
☑ FALSE:对应基值false的Boolean 对象。
☑ TYPE:基本类型boolean 的Class对象

11.1.4 Character类

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

 
public class UpperOrLower {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  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(mychar1+"是小写字母");
   //转换为大写字母输出
   System.out.println("转换为小写字母的结果："+Character.toUpperCase(mychar2));
  }
 }
}//例题11.5

Character类提供了大量表示特定字符的常量，例如：
☑CONNECTOR_PUNCTUATION:返回 byte 型值,表示 Unicode 规范中的常规类别“ Pc ”。
☑ UNASSIGNED:返回byte 型值,表示Unicode规范中的常规类别“Cn”。
☑TITLECASE_LETTER:返回 byte 型值,表示 Unicode 规范中的常规类别“ Lt ”。

说明：Character类提供的常量有很多,详细列表可查看Java API文档。

11.1.5 Number类

数值包装类的共有方法：

11.2数字处理

11.2.1数字格式化

在Java中，没有格式化的数据遵循以下原则：

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

2.如果数据绝对值小于0.001或者大于10000000，是用科学计数法表示。

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);
   }
    //使用applyPattern（）方法对数字进行格式化
   static public void UseApplyPatternMethodFormat(String pattern,double value) {
   DecimalFormat myFormat =new DecimalFormat();
    myFormat.applyPattern(pattern);
     System.out.println(value+""+pattern+""+myFormat.format(value));
     
    }
    public static void main(String[] args) {
     SimgleFormat("###,###,###",123456.789);
     SimgleFormat("00000000.###",123456.789);
     //按照格式化模板格式化数字，不存在的位以0显示
     SimgleFormat("000000.000",123.78);
     //调用静态 UseApplyPatternMethodFormat（）方法
     UseApplyPatternMethodFormat("#.###%", 00.789);
     UseApplyPatternMethodFormat("###.##", 123456.789);
     UseApplyPatternMethodFormat("0.00\u2030", 0.789);  
   }
 }
  
  //例题11.6

11.2.2Math类

Math类提供了众多数学函数方法，这些方法都被定义为static形式

形式调用如下：Math.数学方法

在Math类中，除了函数方法外还存在一些常用数学常量，如PI、E。

形式调用如下：

Math.PI

Math.E

1.三角函数方法

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):将弧度转换为角度。

 
public class TrigonometricFunction {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println("90度的正弦值为："+Math.sin(Math.PI/2));
  System.out.println("0度的余弦值："+Math.cos(0));
  System.out.println("90度的正弦值为："+Math.tan(Math.PI/3));
 
  //取2的平方根与2商的反正弦
  System.out.println("取2的平方根与2商的反正弦"+Math.asin(Math.sqrt(2)/2));
  
  //取2的平方根与2商的反余弦
  System.out.println("取2的平方根与2商的反余弦"+Math.asin(Math.sqrt(2)/2));
  System.out.println("1的反正切值"+Math.atan(1));
  System.out.println("120度的弧度制"+Math.toRadians(120.0));
  System.out.println("Π/2的角度值"+Math.toDegrees(Math.PI/2));
 
 }
 
}
//例题11.7

2.指数函数方法

Math类中与指数相关的函数方法如下。
☑ public static double exp(double a):用于获取e的a次方,即取eᵃ。
☑ public static double log(double a):用于取自然对数,即取lna的值。
☑ public static double log10(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次方。

 
public class ExceponentFunction {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println("e的平方值"+Math.exp(2));
  System.out.println("以e为底的2的对数值"+Math.log(2));
  System.out.println("以10为底2的对数值"+Math.log10(2));
  System.out.println("4的平方根值"+Math.sqrt(4));
  System.out.println("8的立方根值"+Math.cbrt(8));
  System.out.println("2的2次方值"+Math.pow(2, 2));
  
 }
 
}
//例题11.8

3.取整函数方法

　　在具体的问题中，取整操作使用也很普遍，所以Java 在Math类中添加了数字取整方法。Math类中主要包括以下几种取整方法：
☑ 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 后返回与参数最近的整数,然后强制转换为长整型。

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

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

 
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(0, 0));
		System.out.println("-7的绝对值"+Math.abs(-7));
	}
 
}
//例题11.10

11.2.3Random类

Random对象创建一个随机数生成器语法如下：

Random r = new Random;

设置随机数生成器的种子语法如下：

Random r = new Random(seedValue);

r: Random类对象。
seedValue：随机数生成器的种子。
在Random类中，提供了获取各种数据类型随机数的方法，下国之伙2今孙田计前
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):返回一个概率密度为高斯少士8台晰明向叶进研

import java.util.Random;
 
public class RandomDemo {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Random r = new 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());
  
  
  
 }
 
}
//例题11.11

11.2.4 BigInteger类

在Biglnteger类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。
使用BigInteger类，可以实例化一个BigInteger对象，并自动调用相应的构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。
例如，将2转换为BigInteger类型，可以使用以下语句进行初始化操作：

Biglnteger twolnstance =new Biglnteger("2");

注意:参数2的双引号不能省略，因为参数是以字符串的形式存在的。

一旦创建了对象实例，就可以调用Biglnteger 类中的一些方法进行运算操作，包括基本的数学。算和位运算以及一些取相反数、取绝对值等操作。下面列举了Biglnteger类中常用的几种运算方法：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(BigInteger val):用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。
public BigInteger pow(int exponent):进行取参数的exponent次方操作。
public BigInteger negate()：取相反数。
public Biglnteger shiftLeft(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(Biglnteger val)：返回较大的数值。

例题11.12

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]);
  System.out.println("做2次方操作："+b1.pow(2));
  System.out.println("取相反数操作："+b1.negate());
  
 }
 
}
//例题11.12

11.2.5BigDecimal类

在BigDecimal类，常用的两个构造方法如下：

BigDecimal类实现的加减乘除的方法如下：

BigDecimal类中divide（）方法有多种设置，用于但会商小数点后的末尾的处理，名称和含义如下：

import java.math.BigDecimal;
import java.math.RoundingMode;
 
public class BigDecimalDemo {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
   //11.2.4 BigDecimal
    BigDecimal b1=new BigDecimal("0.728382834535");
    BigDecimal b2=new BigDecimal("0.00045353");
    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.13

11.3 System类

System类是JDK中提供的系统类，该类是用final修饰的，所以不允许被继承。Svstem类提供
服多系线层面的操作方法，并且这些方法全部都是静态的。System类提供的较常用方法如下：

11.3.1 控制台输出字符

1.不会自动换行的print()方法
printO方法的语法如下：

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

此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。
2. 可以自动换行的 println()方法

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

System.out.println(”书籍是人类进步的阶梯！”)；

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

print()方法与println()方法输出的对比效果如下：

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

System.out.print("\n"); //利用换行符\n 实现奂行
System.out.println(); //空参数即可实现换行

误区警示：
使用这两个输出方法时还要注意以下两点：
(1)“System.out.println("n")；”会打印两个空行。
(2)“System.out.print);”无参数会报错。

11.3.2 计时

public class SystemTimeDemo {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
 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)+"毫秒");
 }
 
}
//例题11.14

11.4 Scanner类

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

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

下表所示的常用的方法，通过这些方法可以获取控制台中输入的不同类型的值

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

Scanner sc = new Scanner(System.in);

import java.util.Random;
import java.util.Scanner;
 
public class ScannerDemo {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Random r = new Random();
		int num =r.nextInt(100);
		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();
	}
 
}
//例题11.15

11.5日期时间类

11.5.1Date类

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

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

Date date =new Date(timeMillis);

Date类的常用方法及其说明如下：

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.16

11.5.2日期时间格式化
DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化。DateFormat类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种：
SHORT：完全为数字，如12.13.52或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();

DateFormat 类的常用方法及其说明如下：

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

DateFormat df = DateFormat. getinstance();
system.out.printin(df.format(new Date());

结果如下：

2021/2/19上午9:59

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

DateFormat df =DateFormat.getTimelnstance(DateFormat.LONG);
System.out.printn(df.format(new Date());

结果如下：

CST 上午10:00:33

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

DateFormat df=DateFormat.getDate/nstance(DateFormat.LONG);
System.out.printin(df.format(new Date());

结果如下：

2021年2月19日

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

DateFormat df = DateFormat.getDate Timelnstance(DateFormat.LONG, DateFormat.LONG);System,out.println(df.format(new Date()));

结果如下：

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

SimpleDateFormat类提供了19个格式化字符，如下：

一些常用的日期时间格式如下：

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("yyyy年MM月dd日 EEEE HH时mm分ss秒");
		System.out.print("各位观众大家好，现在是");
		System.out.print(df.format(new Date()));
		System.out.println("，欢迎收看新闻。");
	}
 
}
//例题11.17

11.5.3Calendar类

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

Calendar rightNow =Calendar.getlnstance();

说明：由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getInstance0方法创建其对象，如果需要创建其对象，必须使用其子类，如GregorianCalendar类。
Calendar类提供的常用字段及其说明如下：

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

		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("yyyy年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 + " 天！");
			}
		}
 
 
//例题11.18

最后对Calendar类的使用做出几点总结：
c.set(Calendar.DAY_OF_MONTH，0)获取的是上个月的最后一天，所以调用前需要将月份往后
加一个月。
Calendar.MONTH的第一个月是使用(）记录的，所以在获得月份数字后要加1。年和日是从
开始记录的，不需要加1。
Calendar.DAY OF_WEEK的第一天是周日，周一是第二天，周六是最后一天。

11.6Runtime类

Runtime类的常用方法如下：

11.6.1执行本地命令
本地命令指的是操作系统的命令。例如，在Linux系统下就表示shell命令，在Windows系统下就表示cmd命令。
Rutime类提供exec()方法让Java代码可以执行系统的命令，exec)方法有很多重载的形式，例如：

Process exec(String command)
Process exec(String， cmdarray)

command：要执行的系统命令，字符串类型。
cmdarray：要执行的命令和相应的命令参数，字符串数组类型。
其实这两个重载方式很类似，如执行“javac hellojava”这行命令，使用第一种重载方式的代码如下：

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

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

String command，=("javac","hello.java"];
Runtime.getRuntime().exec(command);

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

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();
		try {
			Process p = r.exec("hellp");
			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();
		}
		
 
	}
}

11.6.2查看内存

例题11.20

package a;
 
public class MemoryDemo {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Runtime r = Runtime.getRuntime();
		Integer ints[] =new Integer[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));
	}
 
}