《Thinking in Java》学习笔记

[align=center][size=x-large] [color=blue]《Thinking in Java》学习笔记[/color][/size][/align]
这几天刚好利用放假这点空闲时间重新拿起Thinking in Java这本书翻了一下，只能说是翻了翻，看了感兴趣的几章，在这里和大家分享一下，顺便算是一个学习笔记吧！
[size=large][b][color=red]通过异常处理错误[/color][/b][/size]
[b][color=blue]一． 基本异常[/color] [/b]
[b]1. 抛出异常的原理 [/b]
1) 像产生一个Java对象那样在heap上以new产生一个异常对象。
2) 停止目前的执行路线，将上述那个异常对象的reference自目前的context丢出。
3) 异常处理机制接手工作，寻找得以继续执行的适当地点。
[b]2. 产生一个异常对象[/b]
异常类有两个构造函数：一个default构造函数；一个带String型参数的构造函数，参数的信息可以通过异常类中的各种方法取出。
[b]3. 异常类的结构 [/b]
1) Error是一些编译期错误或系统错误，一般无需在程序中捕捉到Error异常。
2) Exception是我们能捕捉到的异常，其中Exception异常分 RuntimeException和non-RuntimeException两大类异常。
[color=blue][b]二． 异常的捕捉和处理 [/b][/color]
[b]1. 异常的捕捉 [/b]
1) 通过try…catch就可捕捉异常
2) 捕捉所有异常
如果想捕捉所有异常，只要捕捉Exception异常就行
[color=blue][b]三． 以finally进行清理 [/b][/color]
[b]1. 如果某段代码不管是否发生异常都要执行，那可把它改入finally块中。[/b]

class TestException{
　　 public static void tSql() throws SQLException {
　　 System.out.println("Originating the exception in tSql()");
　　 throw new SQLException("throw in tSql");
　　 }
　　 public void f() throws SQLException{
　　 try{
　　 tSql();
　　 }
　　 catch(SQLException ex){
　　 System.out.println("catch SQLException in f()");
　　 throw ex;//（1） 
　　 }
　　 finally{
　　 System.out.println("finally in f()");
　　 }
　　 }
　　 }
　　 public class Test{
　　 public static void main(String[] args){
　　 TestException te = new TestException();
　　 try{
　　 te.f();
　　 }
　　 catch(SQLException ex){
　　 System.out.println("catch te.f() SQLException in main");
　　 }
　　 catch(Exception ex){
　　 System.out.println("catch te.f() Exception in main");
　　 }
　　 }
　　 }

[b]2. finally造成的异常遗失 [/b]
如果在finally中执行的代码又产生异常，那么在上一层调用中所捕捉到的异常的起始抛出点会是finally所在的函数。

class TestException{
　　 public static void tSql1() throws SQLException {
　　 System.out.println("Originating the exception in tSql()");
　　 throw new SQLException("throw in tSql1");
　　 }
　　 public static void tSql2() throws SQLException {
　　 System.out.println("Originating the exception in tSql()");
　　 throw new SQLException("throw in tSql2");
　　 }
　　 public void f() throws SQLException{
　　 try{
　　 tSql1();
　　 }
　　 catch(SQLException ex){
　　 System.out.println("catch SQLException in f()");
　　 throw ex;//（2） 

　　 }
　　 finally{
　　 System.out.println("finally in f()");
　　 //tSql2();（1） 

　　 }
　　 }
　　 }
　　 public class Test{
　　 public static void main(String[] args){
　　 TestException te = new TestException();
　　 try{
　　 te.f();
　　 }
　　 catch(SQLException ex){
　　 System.out.println("catch te.f() SQLException in main");
　　 System.out.println("getMessage：" + ex.getMessage());
　　 System.out.println("printStackTrace：");
　　 ex.printStackTrace();
　　 }
　　 }
　　 }

[size=large][b][color=red]持有你的对象[/color][/b][/size]
[color=blue][b]一. 容器简介 [/b][/color]
[b]1. 容器的分类 [/b]
Collection：一组各自独立的元素，即其内的每个位置仅持有一个元素。
1) List：以元素安插的次序来放置元素，不会重新排列。
2) Set：不接爱重复元素，它会使用自己内部的一个排列机制
Map：一群成对的key-value对象，即所持有的是key-value pairs。
Map中不能有重复的key，它拥有自己的内部排列机制。
2. 容器中的元素类型都为Object。从容器取得元素时，必须把它转换成原来的类型。
[color=blue][b]二. 容器的详细介绍[/b][/color]
[b]1． Collection [/b]
Collection不提供get()方法。如果要遍历Collectin中的元素，就必须用Iterator。
[color=red]List [/color]
1)List（interface）：List为Collectin加入了一些函数，使它可以在List内进行安插和移除动作。List会产生ListIterator，通过它可以从两个方向来对List进行走访，也可以在List之内进行元素的安插和移除。
2) ArrayList：可以快速随机访问；但当元素的安插或移除发生在List中央位置时，效率很差。不宜用ArrayList来进行安插和移除操作。
3)LinkedList：与ArrayList相反，适合用来进行安插和移除，但随机访问的速度较慢。此外，可以通过LinkedList来实现stack、queue、deque。
4) LinkedList中的addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()函数未定义于任何一个interface或baseclass中，所以只能用于LinkedList中。
[color=red]Set [/color]
1)Set（interface）：Set具有和Collection一模一样的interface（区别：List加入了自己的函数），所以Set就是一个Collection，只不过其行为不同罢了。加至Set内的每个元素都必须独一无二，不与其他元素重复；Set不允许持有重复元素，每个元素都必须定义equals()以判断所谓的独一性。
2)HashSet：一种把查找时间看得很重要的Sets。所有元素都必须定hashCode
3)TreeSet：底层结构为tree的一种有序的Set。
[color=red]Map[/color]
1)Map：维护key-value的关联性，使你可以使用key来查找value。
2)KeySet()函数和values()函数

public class ExplicitStatic{ 
　　 public static void printKeys(Map m){ 
　　 System.out.print("Size = " + m.size()); 
　　 System.out.println(" , Keys: " + m.keySet()); 
　　 } 
　　 public static void printValues(Map m){ 
　　 System.out.println("Values: " + m.values()); 
　　 } 
　　 public static void test(Map m){ 
　　 for( int i=1; i<10; i++)
　　 m.put("km" + i, "m" + i); 
　　 printKeys(m); 
　　 printValues(m); 
　　 System.out.println("km1 - " + m.get("km1")); 
　　 Set keys = m.keySet(); //（1） 
     Collection values = m.values(); //（2） 
     keys.remove("km2"); //（3） 
     values.remove("m1"); //（4） 
     System.out.println("km1 - " + m.get("km1")); 
　　 printKeys(m); 
　　 printValues(m); 
　　 } 
　　 public static void main(String[] args){ 
　　 System.out.println("Testing HashMap"); 
　　 test(new HashMap()); 
　　 } 
　　 } 

　　 　　
结果分析：在（1）（2）处代码分别得到了Map中的keys和values。从执行（3）（4）前后的代码可知，对通过keySet()和values()函数取得的值进行修改会反映到Map本身。 （3）中删除的是值为“km2”的key，（4）删除的是值为“m1”的value，且它们是同一个key-value pair，但结果（5）（6）表明，Map中删除的是两个key-pair。从而可知，只要删除了Map中的key或value中的一个，那么整个key-valuepair就会被删除。
2.2. HashMap：可在常量时间内安插元素，或找出一组key-valuepair。通过其构造函数，使用者可以调整效能表现，因为它允许你设定capacity（容量）和loadfactor（负载因子）。
2.3. TreeMap：当你检视其中的key或key-valuepairs时，会以排序形式出现，让你得到以排序形式得到结果。TreeMap是惟一具有subMap()的一个Map，这个函数让你得以返回tree中的部分组成。
[color=blue][b]四. HashMap的一些其它讨论 [/b][/color]
1． 关于HashMap中的key值的使用
以Java的库函数做为HashMap的key值时，可以直接使用。

class Counter{ 
　　 int i = 1; 
　　 public String toString(){ 
　　 return Integer.toString(i); 
　　 } 
　　 } 
　　 public class ExplicitStatic{ 
　　 public static void main(String[] args){ 
　　 HashMap hm = new HashMap(); 
　　 for(int i = 0; i < 10000; i++) 
    { 
　　 //HashMap的key的类型为Integer 
　　 Integer r = new Integer((int) (Math.random() * 20)); 
　　 if(hm.containsKey(r)) 
    ((Counter)hm.get(r)).i++; 
    else 
　　 hm.put(r, new Counter()); 
　　 } 
　　 System.out.println(hm); 
　　 } 
　　 }