java中try 与catch的使用

Posted 2023-04-12 竖子敢尔

try
//代码区
catch(Exception e)
//异常处理

代码区如果有错误，就会返回所写异常的处理。
 
首先要清楚，如果没有try的话，出现异常会导致程序崩溃。
而try则可以保证程序的正常运行下去，比如说：
try
int i = 1/0;
catch(Exception e)
........

一个计算的话，如果除数为0，则会报错，如果没有try的话，程序直接崩溃。用try的话，则可以让程序运行下去，并且输出为什么出错！
try catch 是捕捉try部分的异常，当你没有try catch的时候，如果出现异常则程序报错，加上try catch，出现异常程序正常运行，只是把错误信息存储到Exception里，所以catch是用来提取异常信息的，你可以在Catch部分加上一句System.out.println(e.ToString());，如果出现异常可以把异常打印出来
 

Java的异常处理机制(try…catch…finally)

1 引子
try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。

public class TestException 
public TestException() 


boolean testEx() throws Exception 
boolean ret = true;
try 
ret = testEx1();
 catch (Exception e) 
System.out.println("testEx, catch exception");
ret = false;
throw e;
 finally 
System.out.println("testEx, finally; return value=" + ret);
return ret;



boolean testEx1() throws Exception 
boolean ret = true;
try 
ret = testEx2();
if (!ret) 
return false;

System.out.println("testEx1, at the end of try");
return ret;
 catch (Exception e) 
System.out.println("testEx1, catch exception");
ret = false;
throw e;
 finally 
System.out.println("testEx1, finally; return value=" + ret);
return ret;



boolean testEx2() throws Exception 
boolean ret = true;
try 
int b = 12;
int c;
for (int i = 2; i >= -2; i--) 
c = b / i;
System.out.println("i=" + i);

return true;
 catch (Exception e) 
System.out.println("testEx2, catch exception");
ret = false;
throw e;
 finally 
System.out.println("testEx2, finally; return value=" + ret);
return ret;   //有返回值，程序正常结束




public static void main(String[] args) 
TestException testException1 = new TestException();
try 
testException1.testEx();
 catch (Exception e) 
e.printStackTrace();

你的答案是什么？是下面的答案吗？
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
如果你的答案真的如上面所说，那么你错啦。^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。
现在公布正确答案：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false

2 基础知识

2.1 相关概念
例外是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻止程序的正常运行。为了加强程序的鲁棒性，程序设计时，必须考虑到可能发生的异常事件并做出相应的处理。C语言中，通过使用if语句来判断是否出现了例外，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。全程变量ErroNo常常用来反映一个异常事件的类型。但是，这种错误处理机制会导致不少问题。
Java通过面向对象的方法来处理例外。在一个方法的运行过程中，如果发生了例外，则这个方法生成代表该例外的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一例外。我们把生成例外对象并把它提交给运行时系统的过程称为抛弃(throw)一个例外。运行时系统在方法的调用栈中查找，从生成例外的方法开始进行回朔，直到找到包含相应例外处理的方法为止，这一个过程称为捕获(catch)一个例外。

2.2 Throwable类及其子类
用面向对象的方法处理例外，就必须建立类的层次。类 Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个例外被抛弃。图1表示了例外处理的类层次。
从图中可以看出，类Throwable有两个直接子类：Error和Exception。Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类例外进行处理）；Exception类对象是Java程序处理或抛弃的对象。它有各种不同的子类分别对应于不同类型的例外。其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。Java编译器要求Java程序必须捕获或声明所有的非运行时例外，但对运行时例外可以不做处理。

2.3 异常处理关键字
Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。
Throws:  Lists the exceptions a method could throw.
Throw:   Transfers control of the method to the exception handler.
Try：    Opening exception-handling statement.
Catch：  Captures the exception.
Finally： Runs its code before terminating the program.

2.3.1 try语句　
try语句用大括号指定了一段代码，该段代码可能会抛弃一个或多个例外。

2.3.2 catch语句　
catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。
也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。　

2.3.3 finally语句　
try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。

2.3.4 throws语句　
throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java 编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或 RuntimeException， 或它们的子类，这个规则不起作用， 因为这在程序的正常部分中是不期待出现的。 如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。

2.3.5 throw语句　
throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

3 关键字及其中语句流程详解
3.1 try的嵌套
你可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部，写另一个try语句保护其他代码。每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，堆栈就会展开，直到遇到有处理这种异常的try语句。下面是一个try语句嵌套的例子。

class MultiNest 
    static void procedure() 
        try 
            int a = 0;
            int b = 42/a;
         catch(java.lang.ArithmeticException e) 
            System.out.println("in procedure, catch ArithmeticException: " + e);
        
    
    public static void main(String args[]) 
        try 
            procedure();
         catch(java.lang. Exception e) 
            System.out.println("in main, catch Exception: " + e);
        
    

这个例子执行的结果为：

in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
成员函数procedure里有自己的try/catch控制，所以main不用去处理 ArrayIndexOutOfBoundsException；当然如果如同最开始我们做测试的例子一样，在procedure中catch到异常时使用throw e;语句将异常抛出，那么main当然还是能够捕捉并处理这个procedure抛出来的异常。例如在procedure函数的catch中的System.out语句后面增加throw e;语句之后，执行结果就变为：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
in main, catch Exception: java.lang.ArithmeticException: / by zero

3.2 try-catch程序块的执行流程以及执行结果
相对于try-catch-finally程序块而言，try-catch的执行流程以及执行结果还是比较简单的。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
    1．如果try块中所有语句正常执行完毕，那么就不会有其他的“动作”被执行，整个try-catch程序块正常完成。
    2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
-->如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。
-->如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止（completes abruptly）”。
    3．如果try由于其他原因R突然中止（completes abruptly），那么这个try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）“。
    
3.3 try-catch-finally程序块的执行流程以及执行结果
try-catch-finally程序块的执行流程以及执行结果比较复杂。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
1．如果try块中所有语句正常执行完毕，那么finally块的就会被执行，这时分为以下两种情况：
-->如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
-->如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
-->如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：
-->如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：
---->如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
---->如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
-->如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：
---->如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
---->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
（注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throw e抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是complete abruptly的（别小看这个用得最多的return，它也是一种导致complete abruptly的原因之一啊——后文中有关于导致complete abruptly的原因分析），所以整个try-catch-finally程序块的结果是“complete abruptly”，所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的，而只能将finally中的return结果获取到。
如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值，那么一定要注意你所调用的下级函数中的finally语句，它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。当然这种情况是可以避免的，以testEx2为例：如果你一定要使用finally而且又要将catch中throw的e在testEx1中被捕获到，那么你去掉testEx2中的finally中的return就可以了。这个事情已经在OMC2.0的MIB中出现过啦：服务器的异常不能完全被反馈到客户端。）
-->如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况：
---->如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止（completes abruptly）”。
---->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，异常V将被抛弃。
3．如果try由于其他原因R突然中止（completes abruptly），那么finally块被执行，分为两种情况：
-->如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
-->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
3.4 try-catch-finally程序块中的return
从上面的try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权（语句流程）转到finally块中；这种情况下一定要注意返回值的处理。
例如，在try或者catch中return false了，而在finally中又return true，那么这种情况下不要期待你的try或者catch中的return false的返回值false被上级调用函数获取到，上级调用函数能够获取到的只是finally中的返回值，因为try或者catch中的return语句只是转移控制权的作用。
3.5 如何抛出异常
如果你知道你写的某个函数有可能抛出异常，而你又不想在这个函数中对异常进行处理，只是想把它抛出去让调用这个函数的上级调用函数进行处理，那么有两种方式可供选择：
第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch。比如将最开始的例子中的testEx2改为下面的方式，那么testEx1就能捕捉到testEx2抛出的异常了。

boolean testEx2() throws Exception
        boolean ret = true;
        int b=12;
        int c;
        for (int i=2;i>=-2;i--)
            c=b/i;
            System.out.println("i="+i);
        
        return true;   

第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：

boolean testEx2() throws Exception
        boolean ret = true;
        try
            int b=12;
            int c;
            for (int i=2;i>=-2;i--)
                c=b/i;
                System.out.println("i="+i);
            
            return true;
        catch (Exception e)
            System.out.println("testEx2, catch exception");
            Throw e;
        
    

第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：

boolean testEx2() throws Exception        boolean ret = true;        try            int b=12;            int c;            for (int i=2;i>=-2;i--)                c=b/i;                System.out.println("i="+i);                throw new Exception("aaa");                        return true;        catch (java.lang.ArithmeticException e)            System.out.println("testEx2, catch exception");            ret = false;            throw new Exception("aaa");        finally            System.out.println("testEx2, finally; return value="+ret);            

4 关于abrupt completion
前面提到了complete abruptly（暂且理解为“突然中止”或者“异常结束”吧），它主要包含了两种大的情形：abrupt completion of expressions and statements，下面就分两种情况进行解释。
4.1 Normal and Abrupt Completion of Evaluation
每一个表达式（expression）都有一种使得其包含的计算得以一步步进行的正常模式，如果每一步计算都被执行且没有异常抛出，那么就称这个表达式“正常结束（complete normally）”；如果这个表达式的计算抛出了异常，就称为“异常结束（complete abruptly）”。异常结束通常有一个相关联的原因（associated reason），通常也就是抛出一个异常V。
与表达式、操作符相关的运行期异常有：
-->A class instance creation expression, array creation expression , or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available.
-->An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero.
-->A field access throws a NullPointerException if the value of the object reference  expression is null.
-->A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null.
-->An array access throws a NullPointerException if the value of the array reference  expression is null.
-->An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.
-->A cast throws a ClassCastException if a cast is found to be impermissible at run time.
-->An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero.
-->An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.
4.2 Normal and Abrupt Completion of Statements
正常情况我们就不多说了，在这里主要是列出了abrupt completion的几种情况：
-->break, continue, and return 语句将导致控制权的转换，从而使得statements不能正常地、完整地执行。
-->某些表达式的计算也可能从java虚拟机抛出异常，这些表达式在上一小节中已经总结过了；一个显式的的throw语句也将导致异常的抛出。抛出异常也是导致控制权的转换的原因（或者说是阻止statement正常结束的原因）。
如果上述事件发生了，那么这些statement就有可能使得其正常情况下应该都执行的语句不能完全被执行到，那么这些statement也就是被称为是complete abruptly.
导致abrupt completion的几种原因：
-->A break with no label
-->A break with a given label
-->A continue with no label
-->A continue with a given label
-->A return with no value
-->A return with a given value A
-->throw with a given value, including exceptions thrown by the Java virtual machine

5 关于我们的编程的一点建议
弄清楚try-catch-finally的执行情况后我们才能正确使用它。
如果我们使用的是try-catch-finally语句块，而我们又需要保证有异常时能够抛出异常，那么在finally语句中就不要使用return语句了（finally语句块的最重要的作用应该是释放申请的资源），因为finally中的return语句会导致我们的throw e被抛弃，在这个try-catch-finally的外面将只能看到finally中的返回值（除非在finally中抛出异常）。（我们需要记住：不仅throw语句是abrupt completion 的原因，return、break、continue等这些看起来很正常的语句也是导致abrupt completion的原因。）

20145207 《Java程序设计》第5周学习总结

一、异常处理

1.语法与继承结构

使用try、catch： Java中所有错误都会被包装成对象，可以尝试(try)执行程序并捕捉(catch)代表错误的对象后做一些处理。使用了try、catch语法，JVM会尝试执行try区块中的程序代码，如果发生错误，执行程序会跳离错误发生点，然后比对catch括号中声明的类型，是否符合被抛出的错误对象类型，如果是就执行catch中的程序代码。 程序中总有一些意想不到的状况所引发的错误，Java中的错误也以对象方式呈现为java.lang.Throwable的各种子类实例。只要能捕捉包装错误的对象，就可以针对该错误做一些处理。 在这里举一个书上的列子关于使用try和catch的例子。

在这个程序中，输入正确的数字，会计算出平均数，结果如下：  

   

 

         

但是，若是不小心输入了并非int的值，就会出现如下的情况：

 

这是另一个关于输入错误的代码，对其一部分进行了判断并纠正

若是输入错误，就会出现以下的结果：

 

2.异常继承结构

错误会被包装为对象，这些对象均可抛出，因此设计错误对象都继承自java.lang.Throwable类，Throwable定义了取得错误信息、堆栈追踪(Stack Trace)等方法，它有两个子类:java.lang.Error与java.lang.Exception。在此简述一下Error类与Exception类的区别，在Java中对于比较严重的问题，是通过Error类来进行描述的，而对于非严重的问题，则是通过Exception类来进行描述的。对于Error，一般不编写针对性的代码对其进行处理，因为此时已经超出了JVM的运行能力范围之外了。

单就语法与继承架构上来说，如果某个方法声明会抛出Throwable或子类实例，只要不是属于Error或java.lang.RuntimeException或其子类实例，就必须明确使用try、catch语法加以处理，或者在方法中用throws声明这个方法会抛出异常，否则会编译失败，throws的使用也提高了代码的安全性。

Exception中有一个特殊的子类异常叫RuntimeException异常，就是运行时异常，它的特点是如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过，如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。Exception或其子对象，但非属于RuntimeException或其子类对象，称为受检异常(Checked Exception)，属于RuntimeException衍生出来的类实例亦称为非受检异常(Unchecked Exception)，受检异常存在的目的，在于API设计者实现某方法时，某些条件成立时会引发错误，而且认为调用方法的客户端有能力处理错误，要求编译程序提醒客户端必须明确处理错误，不然不可通过编译，API客户端无权选择要不要处理。

如果父类异常对象在子类异常对象前被捕捉，则catch子类异常对象将永远不会被执行，编译程序会检查出这个错误。从JDK7开始，可以使用多重捕捉语法，不过仍需注意异常的继承，catch括号中列出的异常不得有继承关系，否则会发生编译错误。

在catch区块进行完部分错误处理之后，可以使用throw将异常再度抛出，这里将throw和throws要区分开，throws使用在函数上，后面跟的是异常类，可以跟多个，用逗号隔开，而throw是使用在函数内，后面跟的是异常对象。

若想得知异常发生的根源，以及多重方法调用下异常的堆栈传播，可以利用异常对象自动收集的堆栈追踪来取得相关信息，例如调用异常对象的printStackTrace()、getStackTrace()等方法。要善于堆栈追踪，前提是程序代码中不可有私吞异常的行为、对异常做了不适当的处理，或显示了不正确信息。在使用throw重抛异常时，异常的追踪堆栈起点，仍是异常的发生根源，而不是重抛异常的地方。如果想要让异常堆栈起点为重抛异常的地方，可以使用fillInStackTrace()，这个方法会重新装填异常堆栈，将起点设为重抛异常的地方，并返回Throwable对象。

3.异常与资源管理

程序中因错误而抛出异常时，原本的执行流程就会中断，抛出异常处之后的程序代码就不会被执行，如果程序开启了相关资源，是否在使用完毕后被关闭了呢？

finally区块

最后一定要执行关闭资源的动作,try、catch语法还可以搭配finally，无论try区块中有无发生异常，若撰写finally区块，则finally区块一定会被执行。举一个例子：

由于finally区块一定会被执行，在这个范例中scanner原先是null，若FileInputStream创建失败，则scanner就有可能还是null，因此在finally区块中必须先检查scanner是否有参考对象，有的话才进一步调用close（）方法，否则scanner参考至null又打算调用close（）方法，反而会抛出NullPointerException。 想要尝试关闭资源(Try-With-Resources)的对象，是撰写在try之后的括号中，如果无须catch处理任何异常，可以不用撰写，也不要撰写finally。尝试关闭资源语法可套用的对象，必须操作java.lang.AutoCloseable接口，该语法也可以同时关闭两个以上的对象资源，只要中间以分号隔开。在try的括号中，越后面撰写的对象资源会越早被关闭。

二、Collection与Map

1.认识Collection架构

JavaSE提供了满足各种需求的API，在使用这些API前，建议先了解其继承与接口的操作架构，才能了解何时该采用哪个类，以及类之间如何彼此合作，而不会沦为死背API或抄写范例的境界。

收集对象的行为，像是新增对象的add()方法、移除对象的remove()方法等，都是定义在java.util.Collection中。既然可以收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义的行为，它定义了iterable()方法返回java.util.Iterator操作对象，可以让你逐一取得收集的对象。Collection接口中有三个子接口，分别是List、Set和Queue。如果希望收集时记录记录每个对象的索引顺序，并可依索引取回对象，可以使用java.util.List接口，如果希望收集的对象不重复，具有集合的行为，可以使用java.util.Set接口，如果希望收集对象时以队列方式，收集的对象假如至尾端，取得对象时从前端，则可以使用java.util.Queue接口，如果希望对Queue的两端进行加入、移除等操作，则可以使用java.util.Deque。

2.键值对应的Map

就如同网络搜素，根据关键字可找到对应的数据，程序设计中也常有这类的需求，根据某个键来取得对应的值。可以事先利用java.util.Map接口操作对象来建立键值对应数据，之后若要取得值，只要用对应的键，只要用对应的键就可以迅速取得。 常用Map操作类有HashMap、TreeMap和Properties。HashMap的特点是线程不安全，速度快，允许存放null 键，null值，TreeMap会对键进行排序，条件是作为键的对象必须操作Comparable接口，或者是在创建TreeMap时指定操作Comparable接口的对象，Properties的setProperty()可以指定字符串类型的键值，getProperty()可以指定字符串类型的键，取回字符串类型的值，通常称为属性名称与属性值。

教材学习中的问题和解决过程

书中P295 MapKeyValue.java运行结果与书中采用HashMap显示不同

代码调试中的问题和解决过程

在这两章中我发现了有些东西按照书上来的话，是没有办法编译通过的，还有就是例如266页的代码，他也是前后使用的变量名不一样，前面定义的是object o，后面就拉过来一个elem，我觉得书上有错误是正常的，刚好可以顺便检测我们对于书上以前的内容是否真的了解，以及是否看懂了这段代码。

在收集对象之后，对对象进行排序是常用的动作，你不用亲自操作排序算法，java.util.Collections提供有sort()方法。由于必须有索引才能进行排序，因此Collections的sort()方法接受List操作对象。