新学期第三篇复习博客

程序设计和设计的过程中，发生错误是不可避免的。为此，Java提供了异常处理机制来帮助程序员检查可能出现的错误，保证程序的可读性和可维护性。Java中将异常封装到一个类中，出现错误时就会抛出异常。本章将讲解Java的异常处理机制。

 在程序中，异常可能由程序员没有预料到的各种情况产生，也可能由超出了程序员可控范围的环境因素产生，如用户的坏数据、试图打开一个根本不存在的文件等。在Java中，这种在程序运行时可能出现的一些错误称为异常。异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流。

例题9.1
 

public class Baulk{  //创建类 Baulk
  public static void main(String[]args){   //主方法
        int result =3/0;        //定义int型变量并赋值
        System.out.println(result);  //将变量输出
      }
}

运行结果会报错所以没有展示

程序运行的结果报告发生了算术异常ArithmeticException（根据给出的错误提示可知，发生错误是因为在算术表达式“3/0”中，0作为除数出现），系统不再执行下去，提前结束。这种情况就是所说的异常。

有许多异常的例子，如数组溢出等。Java语言是一门面向对象的编程语言，因此异常在Java语言中也是作为类的实例的形式出现的。当某一方法中发生错误时，这个方法会创建一个对象，并且把它传递给正在运行的系统。这个对象就是异常对象。通过异常处理机制，可以将非正常情况下的处理代码与程序的主逻辑分离，即在编写代码主流程的同时在其他地方处理异常。

9.2异常的抛出与捕捉
为了保证程序有效地执行，需要对抛出的异常进行相应的处理。在Java中，如果某个方法抛出异常，既可以在当前方法中进行捕捉，而后处理该异常，也可以将异常向上抛出，交由方法调用者来处理。本节将讲解Java中捕获异常的方法。

9.2.1抛出异常
异常抛出后，如果不做任何处理，程序就会被终止。例如，将一个字符串转换为整型，可以通过Integer 类的parseInt()方法来实现。但如果该字符串不是数字形式，parseInt()方法就会抛出异常，程序将在出现异常的位置终止，不在执行下面的语句。

例题9.2
 

public class Thundering{  //创建类
    public static void main(String[]args){  //主方法
        String str ="lili";   //定义字符串
        System.out.println(str+"年龄是：");  //输出的提示信息
        int age = lnteger.parselnt("20L"); //数据类型的转换
        System.out.println(age);  //输出信息
        }
       }

运行结果会报错所以不展示

9.2.2捕捉异常 
Java语言的异常捕获结构由try、catch和finally3部分组成。其中，try语句块存放的是可能发生异常的Java语句;catch语句块在try语句块之后，用来激发被捕获的异常;finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何提出，都将执行finally语句块。语法如下：
 

try{
//程序代码块
}
catch(Exceptiontype1 e){
//对 Exceptiontype 1的处理
}
catch(Exceptiontype2 e){
//对 Exceptiontype 2的处理
}
...
finally{
//程序代码块
}

通过异常处理器的语法可知，异常处理器大致分为try-catch语句块和finally语句块。

1.try-catch语句块

将例题9.2修改。

public class Take{  //创建类
    public static void main(String[]args){  //主方法
      try{            //try语句块中包含可能出现异常的程序代码
        String str ="lili";   //定义字符串
        System.out.println(str+"年龄是：");  //输出的提示信息
        int age = lnteger.parselnt("20L"); //数据类型的转换
        System.out.println(age);  //输出信息
        }
           catch(Exception e){            //catch语句块用来获取异常信息
            e.printStack Trace();        //输出异常性质
       }
        System.out.println("program overr");    //输出信息
    }
}

2.finally语句块

完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally语句。但是，在以下四种特殊情况下，finally块不会被执行：

1.在finally语句块中发生了异常

2.在前面的代码中使用了System.exit()退出程序

3.程序所在的线程死亡

4.关闭cpu

9.3Java常见的异常类
在Java中，提供了一些类用来描述继承发生的异常。其中，有的需要程序员进行捕捉处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类如下表所示：

常见的异常类

9.4自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需继承Exception类即可自定义异常类。在程序中使用自定义异常类，大体可分为以下几个步骤：

        (1)创建自定义异常类。

        (2)在方法中通过throw关键字抛出异常对象。

        (3)如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过关键字throw关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

        (4)在出现异常的方法的调用者中捕获并处理异常。
例题9.4
 

public class MyException extends Exception{ //创建自定义异常，继承Exception类
    public MyException(String ErrorMessage){ //构造方法
        super(ErrorMessage);            //父类构造方法
        }
    }

字符串ErroMessage是要输出的错误信息。若想抛出用户自定义的异常对象，要使用throw关键字

例题9.5

public class Tran {
//创建类
static int avg(int number1, int number2) throws MyException {	//定义方法，抛出异常	
if (number1 <0 || number2<0){	//判断方法中参数是否满足指定条件	
throw new MyException("不可以使用负数");	//错误信息	
if (number1 > 100 | number2> 100) {	//判断方法中参数是否满足指定条件	
throw new MyException("数值太大了");	//错误信息	
}
return (number1+ number2)/2;	//将参数的平均值返回	
}
public static void main(String args){	//主方法	
try {	//try语句块处理可能出现异常的代码	
int result =avg(102, 150)	//调用avg()方法	
System.out.printin(result);	//将avg()方法的返回值输出	
}catch(MyException e){
System.out.println(e);	//输出异常信息	
}

运行结果

MyException:数值太大了

9.5在方法中抛出异常

 若某个方法可能会发生异常，但不想在当前方法中处理这个异常，则可以使用throws、throw关键字在方法中抛出异常。

9.5.1使用throws关键字抛出异常

例题9.6

ouale class Shoot !	//创建类	
static void pop() throws NegativeArra ySizeException{
1/定义方法并抛出NegativeArraySi zeException异常
int] arr =new int[-3]:	//创建数组	
public static void main(Stringlargs) {	//主方法	
try{	//try语句处理异常信息	
pop();	//调用pop()方法	
} catch(NegativeArraySizeExcepti ion e) {
System.out.printin(pop()方法	抛出的异常");	//输出异常信息	
}

运行结果

pop（）方法抛出的异常

使用throws关键字将异常抛给上一级后，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

9.5.2使用throw关键字抛出异常
throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句块。

        throw通常用来抛出用户自定义异常。下面通过实例介绍throw的用法。

例题9.7
 

public class MyException extends Exception {	//创建自定义异常类	
String message;	//定义String 类型变量	
public MyException(String ErrorMessagr){	//父类方法	
message=ErrorMessagr;}
public String getMessage(){	//覆盖getMessage()方法	
return message;

例题9.8

public class Captor{
//创建类
static int quotient(int x,int y)throws MyException{	//定义方法抛出异常	
if (y < 0) {	//判断参数是否小于0	
throw new MyException("除数不能是负数");	//异常信息	
return x/ y;	//返回值	
}
try { public static void main(String args){//主方法//try语句块包含可能发生异常的语句
int result = quotient(3,-1);	//调用方法 quotient()	
} catch (MyException e) {	//处理自定义异常	
System.outprintln(egetMessage());	//输出异常信息	
} catch (ArithmeticException e){	//处理ArithmeticException异常	
System.outprintln("除数不能为0");	//输出提示信息	
} catch (Exception e){	//处理其他异常	
System.out.printin("程序发生了其他的异常"); //输出提示信息
}

9.6运行时异常
RuntimeException异常是程序运行过程中抛出的异常。Java类库的每个包中都定义了异常类，所有这些类都是Throwable类的子类。Throwable类派生了两个子类，分别是Exception类和Error类。Error类及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。Exception类称为非致命类，可以通过捕捉处理使程序继续执行。Exception类又根据错误发生的原因分为RuntimeException异常和除RuntimeException之外的异常，如下图所示。

Java中提供了常见的RuntimeException异常，这些异常可通过try-catch语句捕获，如下表所示。

 9.7异常的使用原则
Java异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时，可遵循以下几条原则：

        1.在当前方法声明中使用try-catch语句捕获异常。

        2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。

        3.如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。
 

try 尝试

catch 捕捉

 字符串是Java程序中经常处理的对象，如果字符串运用得不好，将影响到程序运行的效率。在Java中，字符串作为String类的实例来处理。以对象的方式处理字符串，将使字符串更加灵活、方便。了节字符串上可用的操作，可以节省程序编写与维护的时间。本章从创建字符串开始讲解字符串本身的特性以及字符串上可用的重要操作等。

10.1String类
单个字符可以用char类型保存，多个字符组成的文本就需要保存在String对象中。String通常被称为字符串，一个String对象对象最多可以保存（2的32次方-1）个字节（占用4GB空间大小）的文本内容。

10.1.1声明字符串
在Java语言中，字符串必须包含在双引号“”之内

10.1.2创建字符串
在Java语言中，将字符串作为对象来处理，因此可以像创建其他类对象一样来创建字符串对象。创建对象要使用类的构造方法。String类的常用构造方法如下。

String（char a[])

该方法用以一个字符数组a创建Sting对象，代码如下：

 

char a[]={'g','o','o','d'};
String s = new String(a);
 
 
//等同于
 
 
String s =new Sting("good")

这是最常见的方法

10.2连接字符串
对于已声明的字符串，可以对其进行相应的操作，连接字符串就是字符操作中较简单的一种。可以对多个字符串进行连接，也可使字符串与其他数据类型进行连接。

10.2.1连接多个字符串
使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。

例题10.1
 

public class Join{  //创建类
    public static void main(String args[]){ //主方法
        String s1 =new String("春色绿千里");  //声明String对象s1
        String s2 =new String("马蹄香万家");  //声明String对象s2
        string s =s1 +"\n"+s2;  //将对象s1、“\n”和对象s2连接并将结果赋值给s
        System.out.println(s);    //将s输出
    }
}

输出结果

春色绿千里
马蹄香万家

10.2.2连接其他数据类型

字符串也可同其他基本数据类型进行连接。如果将字符串同其他类型数据进行数据类型的数据直接转换成字符串。

例题10.2

public class Link{      //创建类
    public static void main(String args[]){    //主方法
        int booktime =4;        //声明的int型变量booktime
        float practice =2.5f;  //声明的float型变量practice
        //将字符串与整型、浮点型变量相连，并将结果输出
        System.out.println("我每天花费"+booktime+"小时看书;"+practice+"小时上机练习");
        }
}

运行结果

我每天花费4小时看书;6.5小时上机练习

在这里booktime和practice都不是字符串，当他们与字符串相连时会自动调用toString（）方法并转换成字符串形式，然后参与字符串连接。

10.3获取字符串长度
字符串作为对象，可通过相应方法获取字符串的有效信息，如获取某字符串的长度、某个索引位置的字符串等。本节将讲解几种获取字符串的相关信息的方法。

10.3.1获取字符串长度
使用Sring类的length（）方法可获取声明的字符串对象的长度。语法如下：

str.length();

其中，str为字符串对象。

获取字符串长度，代码如下：

String str ="We are students";
int size =str.length();String str ="We are students";

      

10.3.2字符串查找
String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是搜索的字符或字符串首次出现的位置，lastIndexOf()方法返回的是搜索的字符或字符串最后一次出现的位置。

        (1)indexOf(String s)

        该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用String类的indexOf()方法时，会从当前字符串的位置开始搜索s的位置。如果没有检索到字符串s，该方法的返回值是-1。语法如下：
 

str.indexOf(substr)
 str：任意字符串对象。

        substr：要搜索的字符串。

        查找字符a在字符串str中的索引位置，代码如下：

String str = "We are students";
int size = str.indexOf("a");//变量size的值是3
(2)lastindexOf(String str)

        该方法用于返回指定字符串最后一次出现的索引位置。当调用String类的lastIndexOf()方法时，会从当前字符串的开始位置检查参数字符串str，并将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1。语法如下：
 

str.lastIndexOf(substr)
 str：任意字符串对象。

        substr：要搜索的字符串。

        说明lastIndexOf()方法中的参数是空字符串""（注意没有空格），则返回的结果与调用length()方法的返回结果相同。

public class Test {
 
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String str = "we are students";//定义字符串str
        int size = str.lastIndexOf("");//将空字符串在str中的索引位置赋值给变量size
        System.out.println("空字符串在字符串str中的索引位置是："+size);//将变量size输出
        System.out.println("字符串str的长度是："+str.length());//将字符串str的长度输出
    }
 
}
空字符串在字符串中str中的索引位置是15
字符串str的长度是15
10.3.3获取指定索引位置的字符
使用charAt()方法可将指定索引处的字符返回。语法如下：

str.charAt(index)
str：任意字符串。

        index：整型值，用于指定要返回字符的下标。

        例题：查看指定索引位置上的字符

        在项目中创建Ref类，在主方法中创建String对象，使用charAt()方法查看字符串，str中索引位置是6的字符。

public class Ref {
 
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String str = "hello word";//定义字符串str
        char mychar = str.charAt(6);//将字符串str中索引位置是6的字符返回
        System.out.println("字符串str中索引位置是6的字符为："+mychar);//输出信息
    }
 
}
字符串str中索引位置是6的字符为w
10.4字符串操作 
 （1）获取子字符串
通过string类的substring（）方法可对字符串进行截取。substring（）方法被两种不同的重载形式，来满足不同的需求。

1，substring（int beginIndex）【前索引，后索引（前含后不含）】该方法返回是从指定的索引位置开始截取直到该字符串结尾的子串
str.substring(int beginIndex)

beginIndex:指定从某一索引处开始截取字符串   代码如下：

String str = "hello word";
String substr = str.substring(3);
public class Subs {
 
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String str = "《将进酒》:李白(唐)";//定义的字符串
        String substr = str.substring(6,8);//对字符串进行获取
        System.out.print("《将进酒》的作者是："+ substr);//输出获取后的字符串
    }
 
}
《将进酒》的作者是：李白
10.4.2去除空格
trim()方法返回字符串的副本，忽略前导空格和尾部空格：

str.trim()
public class Black {
    //创建类
     public static void main(String[] args) {//主方法
      // TODO Auto-generated method stub
      String str = "   java  class   ";//定义字符串str
      System.out.println("字符串原来的长度："+str.length());
      //教案str原来的长度输出
      //将str去掉前导空格和尾部空格后的长度输出
      System.out.println("去掉空格后的长度："+str.trim().length());
     }
 
}
字符串原来的长度：17
去掉空格后的长度：11
10.4.3字符串替换
replace（）方法可实现将指定的字符或字符串替换成新的字符或字符串。

str.replace(CharSequence target,CharSequence replacement)

 
public class NewStr {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str = "address";//定义字符串str
  String newstr = str.replace("a", "A");
  //将str中“a”替换成“A”并返回新字符串newstr
  System.out.println(newstr);//输出
 }
 
}
10.4.4判断字符串的开始与结尾
startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束，这两个方法的返回值都是Boolean类型。

1，startsWith()方法   该方法用于判断当前字符串对象的前缀是否为参数指定的字符串结束

str.startsWith(String prefix)

prefix:指作为前缀的字符串

2，endsWith方法   该方法用于判断当前字符串是否为以给定的字符串结束

str.endsWith(String suffix)

public class StartOrEnd {
 
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String num1 = "22045612";
        String num2 = "21304578";
        boolean b = num1.startsWith("22");//判断字符串num1是否以22开始
        boolean b2 = num2.endsWith("78");//判断字符串num2是否以78结束
        System.out.println("字符串num1是以‘22’开始的吗？"+b);
        System.out.println("字符串num2是以‘78’结束的吗？"+b2);//输出信息
    }
 
}
字符串num1是以‘22’开始的吗？true
字符串nun2是以‘78’结尾的吗？true
10.4.5判断字符串是否相等
       
1.对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。
        2.即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用比较运算符比较两个字符串，代码如下：
String tom = new String("i am a student");
String jerry = new String("i am a student");
boolean b = (tom == jerry);
        因此，要比较两个字符串内容是否相等，应使用equals()方法和equalsignorecase()方法。
        3.equals()方法

    1.如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。语法如下：
str.equals(String otherstr)

4.equalsIgnoreCase（）方法
                1.忽略了大小写的情况比较两个字符串是否相等，返回结果为Boolean类型。语法如下：

str.equalsIgnoreCase（String otherstr）

public class Opinion {
 
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String s1 = new String("abc");
        String s2 = new String("ABC");
        boolean b = s1.equals(s2);
        boolean b2 = s2.equalsIgnoreCase(s2);
        System.out.println(s1 + "equals" + s2 + ":" + b);
        System.out.println(s1 + "equalsIgnoreCase" + s2 + ":" + b2);
    }
 
}
10.4.6按字典顺序比较两个字符串
 compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按子典顺序此String对象位于之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。语法如下：
 

str.compare To(String otherstr)
 其中，str、otherstr是要比较的两个字符串对象。

        说明：compareTo()方法只有在equals(Object)方法返回true时才返回0。

        例题：判断字母b的位置

        在项目中创建Wordbook类，在主方法中创建3个String变量，它们的值分别为a、b和c，使用compare To()方法判断字母b的位置，即在字母a的后面，在字母c的前面。实例代码和结果如下：
 

public class Wordbook {
 
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String str = new String("b");
        String str2 = new String("a");
        String str3 = new String("c");
        System.out.println(str + "compareTo" + str2 + ":"
        + str.compareTo(str2));
        System.out.println(str + "compareTo" + str3 + ":"
                + str.compareTo(str3));
    }
}
compareTo：1
compareTo：-1
10.4.7字母大小写转换
String类的toLowerCase()方法可将字符串中的所有大写字母改写为小写字母，而toUpperCase()方法可将字符串中的所有小写字母改成大写字母。

        (1)toLowerCase()方法

        该方法将字符串中的所有大写字母转换为小写字母。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。语法如下：
str.toLowerCase()

 其中，str是要进行转换的字符串

        (2)toUpperCase()方法

        该方法将字符串中的所有小写字母转换为大写字母。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个小写字母都转换成大写，字符串长度不变。语法如下：

其中，str是要进行转换的字符串

        说明：使用toLowerCase方法和toUpperCase()方法进行大小写转换时，数字或其他非英文字母类字符不受影响。

10.4.8字符串分割
使用split()方法可以使字符串按指定的分割字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了以下两种字符串分割形式。

        (1)split(String sign)

        该方法可根据给定的分割符对字符串进行拆分。语法如下：
str.split(String sign)

其中，sign为分割字符串的分割符，也可以使用正则表达式。

        说明：没有统一的对字符进行分割的符号。如果想定义多个分割符，可使用符合“|”。例如“|=”表示分割符为“，”和“=”。

        (2)split(String sign,int limit)

        该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。语法如下：
str.split(String sign,int limit)

sign：分割字符串的分割符，也可以使用正则表达式。

        limit：限制的分割次数。

10.5格式化字符串
  String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。

        (1)format(String format,Object...agrs)

        该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。语法如下：

str.format(String format,Object...agrs)
        format：格式字符串
        agrs：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0。

        (2)format(Local l,String format Object...args)

        该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用其指定的语言环境。语法如下：
 

format(Local l,String format Object...args)
 
  l：格式化过程中要应用的语言环境。如果1为null，则不进行本地化。

        format：格式字符串。

        agrs：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可为0。

1.日期和时间字符串格式化
        在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式，一般要编写大量的代码、经过各种算法才能实现。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。

        (1)日期格式化

        返回一个月中的天数，代码如下：
 

Date date = new Date();//创建Date对象date
String s = String.format("%te",date);//创建format()方法date进行格式化

 2.时间格式化

3.格式化常见的日期时间组合

 10.5.2常规类型格式化

10.6使用正确正则表达式
 正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\\d”表示数字0~9中的任何一个，“\\d”就是元字符。正则表达式中的元字符及其意义如下表所示：

 10.7字符串生成器
 创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的String实例，会在内存中创建新的字符串对象。如果重复的对字符串中进行修改，将极大地增加系统开销。而JDK新增了可变的字符序列StringBuilder类，大大提高了频繁增加字符串的效率。
 

public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String str = "";//创建空字符串
        long starTime = System.currentTimeMillis();//定义对字符串执行操作的起始时间
        for(int i = 0;i < 10000;i++) {//利用for循环执行10000次操作
            str = str + i;//循环追加字符串
        }
        long endTime = System.currentTimeMillis();//定义字符串操作后的时间
        long time = endTime - starTime;//计算字符串执行操作的时间
        System.out.println("String消耗时间："+time);//将执行的时间输出
        StringBuilder builder = new StringBuilder("");//创建字符串生成器
        starTime = System.currentTimeMillis();//更新操作执行的时间
        for(int j = 0;j<10000;j++) {//利用for循环进行操作
            builder.append(j);    //循环追加字符    
        }
        endTime = System.currentTimeMillis();//更新操作后的时间
        time = endTime - starTime;//更新追加操作执行的时间
        System.out.println("StringBuilder消耗时间："+time);//将操作时间输出
    }

String消耗时间：84
StringBuilder消耗时间：0
1.append()方法
该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的费据，如int、boolean、char、String、double 或者另一个字符串生成器等。语法如下:

append(content)
 

其中，content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象

2.insert(int offset, arg)方法
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入 int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下:

insert(int offset arg)

 ofset: 字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度。

arg:将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。向字符串生成器中指定的位置添加字符，代码如下:

StringBuilder bf= new StringBuilder("hello")；//创建字符生成器
bf.insert(5，"world");//添加至字符生成器的位置及内容
System.out.println(bf.toString());//此时输出信息为hello word
3.delete(int start , int end)方法（前删后不删）
 移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end-1处的字符。如果不存在这种字符，则一直到序列尾部。如果 stat 等于 end，则不发生任何更改。语法如下:

delete(int start , int end)

start:将要删除的字符串的起点位置
 end:将要删除的字符串的终点位置
删除指定位置的子字符串，代码如下:
 

StringBuilder bf = new StringBuilder("StringBuilder");//创建字符串生成器
bf.delete(5,10);//删除的子字符串
System.out.preintln(bf.toString());//此时输出的信息为Strinder
  

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

包装类    对应基本数据类型    包装类    对应基本数据类型
Byte    byte    Short    short
Integer    int    Long    long
Float    float    Double    double
Character    char    Boolean    boolean
11.1.1 Integer类
java.lang 包中的Integer 类、Byte 类、Short 类和Long 类，分别将基本数据类型int、byte、short和long封装成一个类，由于这些类都是Number类的的子类，区别就是封装不同的数据类型，其包含的方法基本相同，所以本节以Integer类为例讲解整数包包装类。
Integer类在对象中包装了一个基本数据类型int的的值，该类的对象包含一个int类型的字段。此外该类提供了多个方法，能在 int类型和 String类型之间间互相转换，同时还提供了其他一些处理int类型时非常有用的常量和方法。Integer 类的常用方法如表11.2所示。

方法    功能描述
valueOf(String str)    返回保存指定的String值的Integer对象
parseInt(String str)    返回包含在由str指定的字符串中的数字的等价整数值
ro String()    返回一个表示该Integer值的String对象（可以指定进制基数）
to Binary String(int i)    以二进制无符号整数形式返回一个整数参数的字符串表示形式
to HexString(int i)    以十六进制无符号整数形式返回一个整数参数的字符串表示形式
to OctalString(int i)    以八进制无符号整数形式返回一个整数参数的字符串表示形式
equals(Object IntegerObj)    比较此对象与指定的对象是否相等
int Value()    以int型返回此Integer对象
short Value()    以short型返回此Integer对象
byte Value()    以byte型返回此Integer对象
compare To(Integer anotherInteger)    在数字上比较两个Integer对象。如果这两个值相等，则返回0；如果调用对象的数值大于anotherInterger的数值，则返回正值
下面通过一个实例演示Integer 类的常用方法的使用。
【例11.1】Integer类的常用方法

创建一个IntegerDemo类，其中先使用Integer类的parseInt方法将一个字符串转换为int数然后创建一个 Integer对象，并调用其equals方法与转换的int数据进行比较;最后演示使用Integer类的toBinaryString方法、toHexString0方法、toOctalStringO方法和toString0方法将int数据转换进制、十六进制、八进制和不常使用的十五进制表示形式。

public class IntegerDemo{
public static void main(String args){
int num=Integer.parselnt("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.outprintln("456的二进制表示为:"+str2); System.outprintln("456的十六进制表示为:"+str3); System.outprintln("456的八进制表示为:"+str4); System.outprintln("456的十五进制表示为:"+str5);}}
运行结果如下:

int数据与Integer对象的比较:true456的二进制表示为:111001000456的十六进制表示为:1c8456的八进制表示为:710456的十五进制表示为:206
【例11.2】查看Integer类的常量值

public class GetCon {
public static void main(String argsl){
int maxint =Integer.MAX_VALUE //获取Integer 类的常量值 
int minint=Integer.MINVALUE; int intsize =Integer.SIZE
System.out.println("int类型可取的最大值是:"+m haxint); //将常量值输出 
System.outprintln("int类型可取的最小值是:"+m hinint); System.outprintln("int类型的二进制位数是:"+in tsize);}
运行结果如下:

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

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

【例11.3】Double类的常用方法

创建一个DoubleDemo类，先使用Double类的valueOfO方法创建一个Double 对象，然后使用 Double 类的常用方法对该对象进行操作，并查看它们的显示结果。

public class DoubleDemo{
public static void main(Stringl args){
Double dNum =Double.valueOf("3.14"); //创建一个Double对象 
//判断是否为非数字值
System.outprintln"3.14是否为非数字值:"+Double.isNaN(dNum.doubleValue()));//判断大小 System.outprintln("3.14转换为int值为:"+dNum.intValue());//转换为 int 类型
System.outprintln("值为3.14的Double对象与3.14的比较结果:"+dNum.equals(3.14));
//转换为十六进制
System.out.printin("3.14的十六进制表示为:"+Double.toHexString(dNum));}}
运行结果如下：

3.14是否为非数字值:false
3.14转换为int值为:3
值为3.14的Doublo对象与3.14的比较结果:true
3.14的十六进制表示为:0x1.91eb851eb851fp1
11.1.3 Boolean类
bolean将基本类型为boolean的值包装在一个对中。一个Boolcan类型的对象包含一个型为boolean 的字段。此外，此类为boolean 类型和String类型的相互转换提供了许多方法，并提了处理boolean类型时非常有用其他一些常量和方法。Boolean类的常用方法表11.4

方法    功能描述
booleanValue()     将Boolean 对象的值以对应的 boolean 值返回 
equals(Object obj)    判断调用该方法的对象与bj。参数l，且与调用该方法的对象一都表示同一个boolean 值的Boolcan 对象时，才返回true
parseBoolean(String s)     将字符串参数解析为 boolean 值
toString（）    返回表示该boolean 值的 String对象 
valueOf(String s)     返回一个用指定的字符串表示的boolean 值
【例11.4】Boolean类的常用方法

在项目中创建BooleanDemo 类，在主方法中以不同的构造方法创建 Boolean对象，并调用 booleanValue()方法将创建的对象重新转换为boolean类型数据输出。

public class BooleanDemo{
public static void main(String args){
Boolean b1=Boolean.valueOf("true"); //创建Boolean 对象 
Boolean b2=Boolean.valueOf("ok");
System.outprintIn("b1:"+b1.booleanValue()); System.out.printin("b2:"+b2.booleanValue());
运行结果如下：

b1:true
b2:false
11.1.4 Character类
Charecter基为char值该类提供了多种方法，以确定字符的类别(写字母、数字等)从写转成小写，反之然。Character提供很多来完成对字符的操作，常用的方法如表11.5所示。

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

在项目中创建UpperOrLower类，在主方法中创建Character类的对象，通过判断字符的大小写状态确认将其转换为大写还是小写。

public class UpperOrLower {
public static void main(String args[){
Character mychar1=Character.valueOf(A A'); Character mychar2=Character.valueOfa');
if(Character.isUpperCase(mychar1)){ /判断是否为大写字母 
System.outprintn(mychar1+"是大写字母 ");//转换为小写并输出
System.outprintln("转换为小写字母的结果:"+Character.toLowerCase(mychar1))}
if(Character.isLowerCase(mychar2)){ //判断是否为小写字母
System.out.printin(mychar2+"是小写字母");//转换为大写并输出
System.out.println("转换为大写字母的结果:"+Character.toUpperCase(mychar2));}}}
运行结果如下：

A是大写字母
转换为小写字母的结果:a a是小写字母
转换为大写字母的结果:A
11.1.5 Number类
前面外绍了Java包，对于数型的包装类，它们有一个共同的父类--Number类，该类是一个抽象类，它是Byte、Integer、Short、Long、Float和Double类的父类，其子类必须提供将示的数值转换为byte、int、short、long、float和double的方法。例如，doubleValueO方法返回双精度点值，floatValueO方法返回单精度浮点值，这些方法如表 11.6 所示。

方法    功能描述
byteValue()     以byte形式返回指定的数值 
intValue()      以int形式返回指定的数值 
floatValue()     以float形式返回指定的数值
shortValue()     以short形式返回指定的数值
longValue()      以long形式返回指定的数值
doubleValue()    以double形式返回指定的数值 
Number类的方法分别被其各子类所实现，也就是说，在 Number 类的所有子类中都包含以上这几种方法。

11.2数字处理
在Java语言中，提供了一个执行数学基本运算的 Math 类，该类包括常用的数学运算方法，如三角函数方法、指数函数方法、对数函数方法、平方根函数方法等一些常用数学函数方法。除此之外还提供了一些常用的数学常量，如 PI、E 等。本节将设讲解Math类以及其中的一些常用方法。
在实际开发中，随机数的使用是很普遍的，所以以要掌握生成随机数的操作。在 Java 中主要提供了两种生成随机数的方式，分别为调用Math类的rand om()方法生成随机数和调用Random类生成各种数据类型的随机数。
在Java中，还提供了大数字的操作类，即java.n mathBigInteger 类与javamath.BigDecimal 类。这两个类用于高精度计算，其中BigInteger类是针对大整数的处理类，而BigDecimal类则是针对大小数的处理类。

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

由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在Java中，可以使用DecimalFormat类进行格式化操作。
DecimalFormat 类NumberFormat的一个子类，用于格式化十进制数字。它可以将一些数字格化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一般情况下，可以在实例化 DecimalFormat对象时传递数字格式，也可以通过DecimalFormat类 applyPattern()方法来实现数字格式化。
当格式化数字时，可在DecimalFormat类中使用一些特殊字符构成一个格式化模板，使数字按照一定的特殊字符规则进行匹配。表11.7列举了格式化模板中的特殊字符及其所代表的含义。

 【例11.6】DecimalFormat类的常用方法

在项目中创建DecimalFormatSimpleDemo类，在类中分别定义SimgleFormatO方法和 UseApplyPatternMethodFormat(方法实现两种格式化数字的方式。

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.printin(value +""+ pattern +""+myFormat.format(value);
)
public static void main(String args){
SimgleFormat("###,###.#1#", 123456.789); //调用静态 SimgleFormat()方法 
SimgleFormat("00000000.#11#kg", 123456.789); //在数字后加上单位 
//按照格式模板格式化数字，不存在的位以0显示 SimgleFormat("000000.000",123.78);
//调用静态UseApplyPatternMethodFormat()方法
UseApplyPatternMethodFormat("#.#11#%", 0.789); //将数字转换为百分数形式 
UseApplyPatternMethodFormat("#11#.##", 123456.789);//将小数点后格式化为两位
UseApplyPatternMethodFormat("0.00\u2030",0.789); //将数字转换为千分数形式 
}}

运行结果如下：

123456.789 #1#,###.### 123,456.789
123456.789 00000000.#H#kg 00123456.789kg12378 000000.000 000123.780
0.789 #.###% 78.9%
123456.789 #1#.## 123456.79
0.7890.00%789.00%
在本实例中可以看到，代码的第一行使用import 关键字将 java.text.DecimalFormat 这个类导入，这是告知系统下面的代码将使用到DecimalFormat类。然后定义了两个格式化数字的方法，这两个方法的参数都为两个，分别代表数字格式化模板和具体需要格式化的数字。虽然这两个方法都可以实现数字的格式化，但采用的方式有所不同，SimgleFormat()方法是在实例化DecimalFormat 对象时设置数字格式化模板，而UseApplyPatternMethodFormat()方法是在实例化DecimalFormat对象后调用applyPattern()方法设置数字格式化模板。最后，在主方法中根据不同形式模板格式化数字。在结果中可以看到以“0’特殊字符构成的模板进行格式化时，当数字某位不存在时，将显示0;而以“#”特殊字符构成的模板进行格式化操作时，格式化后的数字位数与数字本身的位数一致。
在DecimalFormat类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方法对数字进行格式化设置。例如:

DecimalFormat myFormat=new DecimalFormat(); //实例化 DecimalFormat 类对象 
myFormat.setGroupingSize(2); //设置将数字分组的大小 
myFormat.setGroupingUsed(false); //设置是否支持分组 
在上述代码中，setGroupingSize()方法设置格式化数字的分组大小，setGroupingUsed()方法设置是否可以对数字进行分组操作。为了使读者更好地理解这两个方法的使用，来看下面的实例。
在项目中创建DecimalMethod类，在类的主方法中调用setGroupingSize()与setGroupingUsed)方法实现数字的分组。

import java.text.DecimalFormat;
道
public class DecimalMethod{
除
public static void main(Stringlargs){
DecimalFormat myFormat=new DecimalFormat():
//设置将数字分组为2
myFormat.setGroupingSize(2);
String output=myFormat.format(123456.789);
System.out.printin(将数字以每两个数字分组+output); myFormat.setGroupingUsed(false);
//设置不允许数字进行分组
String output2=myFormat.format(123456.789); System.out.printin(不允许数字分组"+output2);}}
运行结果如下：

将数字以每两个数字分组1234,56.789不允许数字分组123456.789
11.2.2Math类
Math 类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值、最小值，以及平均值函数方法。这些方法都被定义为static形式，所以在程序中应用比较简便。可以使用如下形式调用:
Math.数学方法

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

Math.E

Math类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数困数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。

1.三角函数方法

【例11.7】在Java代码中进行三角函数运算

在项目中创建TrigonometricFunction类，在类的主方法中调用Math类提供的各种三角函数运算方法，并输出运算结果。

public class TrigonometricFunction{
public static void main(Stringl args){
System.out.printin("90度的正弦值:+Math.sin(Math.PI1 2)); //取90的正弦 
System.out.printin("0度的余弦值:"+Math.cos(0)); //取0的余弦 
System.out.printin(60度的正切值:"+Math.tan(Math.Pl/3)); //取60°的正切 
//取2的平方根与2商的反正弦
System.out.printin(2的平方根与2商的反正弦值:+Math.asin(Math.sqrt(2)/2));//取2的平方根与2商的反余弦
System.out.printin2的平方根与2商的反余弦值:"+Math.acos(Math.sqrt(2)/2));
System.out.printin("1的反正切值:"+Math.atan(1)); //取1的反正切 
System.out.printin(120度的弧度值:"+Math.toRadians(120.0)): //取120”的弧度值 
System.out.printin(“m/2的角度值:"+Math.toDegrees(Math.Pl/2)): //取π/2的角度 
}}
运行结果如下：

90度的正弦值:1.00
度的余弦值:1.0
60度的正切值:17320508075688767
2的平方根与2商的反正弦值:07853981633974484
2的平方根与2商的反余弦值:07853981633974483
1的反正切值:0.7853981633974483
120度的弧度值:20943951023931953 
Π/2的角度值:90.0
通过运行结果可以看出，90的正弦值为余弦值为160正切与Math.sqrt(3)的值该是一致的，也就是取3的平方根。在结果中可以看到，第46的值是基本相同的，这个值换算正是，也是获取的Mathsqrt(2)/反正余弦值与反正切值都是45°。最后两行打句实现的是角度和弧度的转换，其中on)度值，Math toDegrees(Math.PI/2)语句是获取2将值形式表示出来，与述结果应该是基本一致的，这些结果不能做到十分精确，因为π本身也是一个近似值。

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的立方根。
M public static double pow(doubleadoubleb):用于取a的b次方。
指数运算包括求方根、取对数以及求n次方的运算。为了使读者更好地理解这些运算函数方法的用法，下面举例说明。
【例11.8】在Java代码中进行指数函数运算

在项目中创建ExponentFunction类，在类的主方法中调用Math类中的方法实现指数函数的运算，并输出运算结果。

public class ExponentFunction{
public static void main(Stringlargs){
System.out.printin("e的平方值:"+Math.exp(2)); //取e的2次方 
System.out.printin("以e为底2的对数值:"+Math.log(2)); //取以e为底2的对数 
Systemout.println(”以10为底2的对数值:"+Math.log10(2)); //取以10为底2的对数 
System.out.println("4的平方根值:"+Mathsqrt(4)); //取4的平方根 
System.out.printIn(8的立方根值:"+Math.cbrt(8)); //取8的立方根 
System.out.printin("2的2次方值:"+Math.pow(2,2)); //取2的2次方 
}}
运行结果如下：

e的平方值:7.38905609893065
以e为底2的对数值:0.6931471805599453
以10为底2的对数值:0.3010299956639812
4的平方根值:2.0
8的立方根值：2.0
2的2次方值：4.0
3.取整函数方法

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

在项目中创建IntFunction类，类法中调用Math的法实现取整数的运算，出运算结果。

public class IntFunction{
public static void main(String args){
System.outprintln("使用ceil()方法取整:"+Mathceil(5.2)); //返回一个大于等于参数的整数 
System.out.println("使用floor()方法取整:"+Math.floor(2.5));//返回一个小于等于参数的整
System.outprintln("使用rint()方法取整:"+Mathrint(2.7)); //返回与参数最接近的整数 
System.outprintln("使用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))
运行结果如下：

使用ceil()方法取整:6.0使用floor()方法取整:2.0
使用rint()方法取整:3.0使用rint()方法取整:2.0
使用round()方法取整：3
使用round()方法取整：3
4.取最大值、最小值、绝对值函数方法

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

在项目中创建AnyFunction 类，在类的主方法中调用Math类中的方法实现求两数的最大值、最小值和取绝对值的运算，并输出运算结果。

publie class AnyFunction(
publle static vold main(Stringlarge){
Syatem.outprintin(4和8较大者:"+M ath.max(4,8)); //取两个参数的最大值 
Syatem.outprintln"4.4和4较小者:"， Math.min(4.4,4)); //取两个参数的最小值 
} System.out.printin("-7的绝对值:"+Mo ath.abs(-7)); //取参数的绝对值 
运行结果如下：

4和8较大者:8
4.4和4较小者:4.0 
-7的绝对值:7
11.2.3 Random类
【例11.11】获取不同取值范围、不同类型的随机数

在项目中创建RandomDemo类，在类的主方法中创建Random类的对象，使用该对象生成各种类型的随机数，并输出结果。

import java.util.Random;
public class RandomDemo{
public static void main(Stringlargs){
Randomr=new Random(); //实例化一个Random类 
//随机产生一个整数
System.out.println("随机产生一个整数:"+r.nextint());//随机产生一个大于等于0且小于10的整数
System.outprintin(随机产生一个大于等于0小于10的整数:"+rnextint(10));//随机产生一个布尔型的值
System.out.printin("随机产生一个布尔型的值:"+r.nextBoolean();//随机产生一个双精度浮点型的值
System.out.printin("随机产生一个双精度浮点型的值:"+r.nextDouble());//随机产生一个单精度浮点型的值
System.outprintln("随机产生一个单精度浮点型的值:"+r.nextFloat());//随机产生一个概率密度为高斯分布的双精度浮点型的值
Systemout.printin("随机产生一个概率密度为高斯分布的双精度浮点型的值:"+r.nextGaussian());
结果：

随机产生一个整数:-991995210
随机产生一个大于等于0小于10的整数:5随机产生一个布尔型的值:true
随机产生一个双精度浮点型的值:0.05001508158115486随机产生一个单精度浮点型的值:0.31018203
随机产生一个概率密度为高斯分布的双精度浮点型的值:0.6781040183219917
11.2.4 BigInteger类
BigInteger类的数字范围较Integer类的数字范围要要大得多。前文介绍过 Integer 类是int 的包装类，
int的最大值为2-1，如果要计算更大的数字，使用 Integer类就无法实现了，所以 Java中提供了 
BigInteger类来处理更大的数字。BigInteger类支持任意精度的整数，也就是说，在运算中 BigInteger类可以准确地表示任何大小的整数值而不会丢失信息。
在BigInteger类中封装了多种操作，除了基本的加 减、乘、除操作，还提供了绝对值、相反数、 
最大公约数以及判断是否为质数等操作。
使用BigInteger类，可以实例化一个BigInteger对象，并自动调用相应的构造函数。BigInteger 类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。
例如，将2转换为BigInteger 类型，可以使用以下语句进行初始化操作:
BigInteger twolnstance=new Biginteger("2");

【例11.12】

import java.math.BigInteger; public class BigIntegerDemo {
public static void main(Stringlargs){
BigInteger b1= new BigInteger("987654321987654321"); //第1个大数字 
Biginteger b2=new BigInteger(“123456789123456789");
System.outprintln("加法操作:"+b1.add(b2)); //加法运算 
//第2个大数字
System.outprintin("减法操作:"+b1.subtract(b2)); /1减法运算 
System.outprintln(乘法操作:"+b1.multiply(b2)); //乘法运算 
System.outprintln(除法操作:"+b1.divide(b2)); //除法运算 
System.outprintln("取商:"+b1.divideAndRemainder(b2)[0]); //取商运算 
Systemoutprintln(取余数:"+b1.divideAndRemainder(b2)[1]); //取余运算 
System.out.printin("做2次方操作:"+b1.pow(2)); 112 次方运算 
} System.out.printin(取相反数操作:"+b1.negate()); //相反数运算 
运行结果如下：

加法操作:1111111111111111110减法操作:864197532864197532
乘法操作:121932631356500531347203169112635269除法操作:8取商:8
取余数:9000000009
做2次方操作:975461059740893157555403139789971041取相反数操作:-987654321987654321
11.2.5 BigDecimal类
BigDecimal类和BigInteger类都能实现大数字的运算，不同的是BigDecimal类加入了小数的概念。一般的float型和double型数据只可以用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到BigDecimal类。BigDecimal类支持任何精度的定点数，可以用它来精确计算货币值。在 BigDecimal 类中，常用的两个构造方法如表 11.8所示。

构造方法    功能说明
BigDecimal(double val)    实例化时将双精度浮点型转换为BigDecimal类型 
BigDecimal(String val)    实例化时将字符串形式转换为BigDecimal类型 
BigDecimal类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运算中除法是最复杂的，因点后的处理是需要考虑的。BigDecimal实现的加、减、乘、除的方法如表11.9所示。

方法    功能说明
add(BigDecimal augend)    做加法操作 
subtract(BigDecimal subtrahend)    做减法操作 
multiply(BigDecimal multiplicand)     做乘法操作
divide(BigDecimal divisor,int scale, RoundingMode）    做除法操作，参分代表除数小数点后的位 数、近似处理模式 
在上述方法中，BgDecimal类中ividc方法有多种设置，用于返回商小数点后的末位的处理，这些模式的名称与含义如表11.10所示。

模式    含义 
RoundingMode.UP    商的最后一位如果大于 0，则向前进位，正负数都如此 
RoundingMode.DOWN    商的最后一位无论是什么数字都省略 
RoundingMode.CEILING    商如果是正数，按照UP模式处理;如果是负数，按照DOWN 模式处理。这种模式的处理都会使近似值大于等于实际值
RoundingMode.FLOOR    与CEILING模式相反，商如果是正数，按照 DOWN 模式处理;商如果是负数，则按照UP模式处理。这种模式的处理都会使近似值小于等于实际值 
RoundingMode.HALF_DOWN    对商进行四舍五入操作，如果商最后一位小于等于5，则做舍弃操作;如果最后一位大于5，则做进位操作，如7.5=7 
RoundingMode.HALF_UP    对商进行四舍五入操作，如果商的最后一位小于5则舍弃;如果大于等于5，进行进位操作，如 7.5≈8
RoundingMode.HALF EVEN    如果商的倒数第二位为奇数，则按照HALF_UP 模式处理;如果为偶数，则按照HALF_DOWN 模式处理，如 7.5=8，8.5≈8
【例11.13】使用BigDecimal类进行数学运算

在项目中创建BigDecimalDemo类，在类的主方法中创建两个BigDecimal类对象，对两个对象进加、减、乘、除运算，并输出运算结果。

import java.math.BigDecimal; import java.math.RoundingMode;
public class BigDecimalDemo {
public static void main(Stringlargs) {
BigDecimal b1 =new BigDecimal(“0.00987654321987654321"): //第1个大小数 
BigDecimal b2=new BigDecimal(“0.00123456789123456789); 11第2个大小数 
System.out.printin(“两个数字相加结果:"+b1.add(b2));
//加法运算
System.out.printin("两个数字相减结果:”+b1.subtract(b2)); 11减法运算 
System.out.printin(两个数字相乘结果:"+b1.multiply(b2)); //乘法运算
//除法运算，商小数点后保留9位，并将结果进行四舍五入操作
Systemoutprintln("两个数字相除，保留留小数点后9位:"+b1divide(b2,9,RoundingMode.HALF_UP));
运行结果如下：

两个数字相加结果:001111111111111111110两个数字相减结果:000864197532864197532
两个数字相乘结果:00000121932631356500531347203169112635269两个数字相除，保留小数点后9位:8.000000073
11.3 System类
System类是JDK中提供的系统类，该类是用final修饰的，所以不允许被继承。System类提供了很多系统层面的操作，并且这些方法全部都是静态的。System类提供的较常用方法如下表所示。本节重点讲解利用System类控制台输出和计时这两个操作。

方法    功能描述
currentTimeMillis()    返回以毫秒为单位的当前时间
exit(int status)    通过启动虚拟机的关闭序列，终止当前正在运行的Java虚拟机。此方法从不正常返回。可以将变量作为一个状态码。根据惯例，非零的状态码表示非正常终止；0表示正常终止
Map<String,String>getenv()    返回一个不能修改的当前系统环境的字符串映射视图
getenv(String name)    获取指定的环境变量值
getProperties()    确定当前的系统属性
getProperty(String key)    获取用指定键描述的系统属性
setIn(InputStream in)    重新分配“标准”输入流
11.3.1控制台输出字符
System类提供了标准输入、标准输出和错误输出流，也就是说，System类提供了3个静态对象：in、out和err。本书中的代码多次使用了这些对象，最常见的就是out对象。在控制台输出字符串，输出的方法有两种，下面分别进行讲解。

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

        print()方法的语法如下：
System.out.print("Hello!");

此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。

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

        println()方法在print后面加上了“ln”后缀（就是line的简写），语法如下：

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

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

        print()方法与println()方法输出的对比效果如下表所示。

Java语法    运行结果    Java语法    运行结果
System.out.println("左");    
       左

       中

       右

System.out.println("上");    
       上

       中

       下

System.out.println("中");    System.out.println("上");
System.out.println("右");    System.out.println("下");
  综上所述，Java输出换行的方法有以下两种：

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

误区警示：

        使用这两个输出方法时还要注意以下两点：

        (1)“System.out.println("\n");”会打印两个空行。

        (2)“System.out.print();”无参数会报错。

11.3.2计时.
 System.currentTimeMillis()方法可以获取自1970年1月1日零点至今的毫秒数。虽然Date日期类也有类似的方法，但代码会比System类多，所以System.currentTimeMillis()方法是为获取当前毫秒数最常用的方法。因为该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。
例题11.14查看一万次字符拼接所消耗的时间 

package 第十一章lnteger;
 
public class StstemTimeDemo {
 
    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+=1;
        }
        long end =System.currentTimeMillis();//记录一个循环后的时间
        System.out.println("循环用时："+(end-start)+"毫秒");//在用循环的后时间减去循环前的时间得到运行消耗时间
    }
 
}

11.4 scanner类
与C语言不同，Java 从台中读出用户输入的值，用的不是一行可以直接使用的代码，而是由一个叫 Scanner 来现canner英文译就是扫描仪，它的用途就和现实生活的扫描仪一可以把数字化信息流转为人类可识别的文字。控制台输出内容用到了 System.out 就表示向控制台输 System.in 表示从控制台输入，让 Scanner 扫描 System.in 就可以获取用户输入的值了使用Scanner类首先要引入该类，其语法如下:
import java.util.Scanner; //引入Scanner类 

canner提供11.13种常用的方法，通过这些方法可以获取控制台中输入的不类型的值

11.15猜数字游戏

代码

package 第十一章lnteger;
 
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=-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.5 日期时间类
在程序开发中，经常需要处理日期时间，java中提供了专门的日期时间类来处理类来处理相应的问题，本节将对java中的日期时间类进行详细讲解

11.5.1 Date类
Date，用造建对，其构造法其明如表 11.14所示。

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

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

例题11.16获取当前的日期和时间并输出

代码

package 第十一章lnteger;
 
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 日期时间格式化
如果在村序中直接输出Datc 对象，示的是“Mon Feb 29 17:39:50 CST 2016”这种格式的日间，何其显示为2016-02-29或者173950这样的日期时间格式呢?Java中提做Danefort类来实现类似的功能，

Datefocmat类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化 
Datefarmat类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期计 F化包HORTMEDIUMLONG和FULL4种:

E SHORT:完全为数字，如 12.13.52或3:30pm

 MEDIUM:较长，如Jan121952
Z LONG:更长，如January12,1952或3:30:32pm
ZFULL:完全指定，如Tuesday、April 12、1952AD或3:30:42pm PST.
另外，使用DaeFormat类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建 Daeeformat类的一个对象，由于它是抽象类，因此可以使用其静态方法getDateInstance(进行创建，语法如下:

Dadsfomat df =DateFormat.getDameInstance（）；
11.5.3 calendar类
打开JavaAPI档看javauilDate提供的大部分法都已经过时了，因为Date类设切没有考虑到国际化，而且很多方法也不能满足用户需求，比如需要获取指定时间的年月日时息，或者想要对日期时间进行加减运算等复杂的操作，Date 类已经不能胜任，因此JDK 提供了新的时间处理类--Calendar日历类。
Calendar 类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF MONTHHOU日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protecte Calendar提供了一个类方法 getInstanceO，以获得此类型的一个通用的对象。Calendar getInstanceO方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如 Calendar rightNow=Calendar.getinstance();
说明
由于 Calendar 类是一个抽象类，不能用 new 创建实例对象，因此除了使用getInstance(方法创建其对象，如果需要创建其对象，必须使用其子类，

如 GregorianCalendar 类字段及其说明如表11.19所示。
、

11.6 Runtime类 
Runtime 类是JDK提供的运行时类，该类为Java程序提供了与当前运行环境相连接的一个通道， Java 程序可以利用该类对当前的运行环境执行一些简单的操作。Runtime类不能使用 new关键字创建
实例，只能通过Runtime.getRuntime()方法获取实例。 制台 
Runtime类的常用方法如表11.21所示，本节将重点讲解利用Runtime类执行本地命令和查看Java虚拟机所占内存这两个操作。

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

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

Process exec(String command)
 Process exec(Stringlcmdarray)

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

例题11.20监控虚拟机内存使用

代码
 

package 第十一章lnteger;
 
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("数组用掉的内存字节数："+(before-after));//输出数组用掉的内存量        
        
     
    }

}