java基礎（五）集合/IO流/異常

這輩子沒辦法作太多事情，因此每一件都要作到精彩絕倫！

People can't do too many things in my life,so everything will be wonderful   

 

本資料只進行簡單介紹說明以及相關重要問題的解答；關於類的詳細說明及使用請參考java API文檔

本文參考的依據是：JDK API 1.6.0 中文版，下載地址：http://down.51cto.com/data/2300228

 

1.      集合

   
   

• 面嚮對象語言對事物的體現都是以對象的形式，因此，爲了方便對多個對象的操做，java就提供了集合類。

• 數組和集合同是容器，有何不一樣？

數組能夠存儲基本類型和引用類型（對象）數據，長度固定；

集合只能存儲對象，長度可變。

• 集合特色：

集合只用於存儲對象，長度可變，能夠存儲不一樣類型的對象。

1.1     Collection接口

• Collection層次結構中的根接口。Collection 表示一組對象，這些對象也稱爲 collection 的元素。一些 collection 容許有重複的元素，而另外一些則不容許。一些 collection 是有序的，而另外一些則是無序的。

• 成員方法：

boolean add(E e)

boolean remove(Object o)

void clear()

boolean contains(Object o)

boolean isEmpty()

int size()

 

boolean addAll(Collection c)

boolean removeAll(Collection c)

boolean containsAll(Collection c)

boolean retainAll(Collection c)

 

Object[] toArray()

把集合轉成數組，能夠實現集合的遍歷

 

Iterator iterator()

迭代器，集合的專用遍歷方式

boolean hasNext()

E next()

1.1.1       Iterator接口

• 是一個接口，還不是具體類？

注意：不要屢次使用hasNext()方法，由於每次都是訪問的同一個對象。

1.1.2       List接口

特色：有序(存儲順序和取出順序一致)，可重複。

1.1.2.1 常見數據結構

A:棧 先進後出

B:隊列 先進先出

C:數組 查詢快，增刪慢

D:鏈表 查詢慢，增刪快

 

 

E：樹：

F：哈希表：

1.1.2.2 List子類特色

l ArrayList類概述

    底層數據結構是數組，查詢快，增刪慢

    線程不安全，效率高

l  Vector類概述

    底層數據結構是數組，查詢快，增刪慢

    線程安全，效率低

l  LinkedList類概述

    底層數據結構是鏈表，查詢慢，增刪快

    線程不安全，效率高

使用場景：要安全嗎?

                                     要：Vector(即便要，也不使用這個，後面再說)

                                     不要：ArrayList或者LinkedList

                                               查詢多；ArrayList

                                               增刪多：LinkedList

什麼都不知道，就用ArrayList

1.1.3       泛型

泛型：是一種特殊的類型，是一種把明確類型的工做推遲到建立對象或調用方法的時候纔去明確的特殊的類型。

格式：<泛型類型>

注意：該類型只能是引用類型。

好處：

1，  把運行時期的問題提早到了編譯期間；

2，  避免了強制類型轉換；

3，  優化了程序設計，解決了×××警告線問題，讓程序更安全。

泛型的由來：

         Object類型做爲任意類型的時候，在向下轉型的時候，會隱含一個轉型問題。泛型就是爲了解決這個問題

泛型類

把泛型定義在類上

格式:public class 類名<泛型類型1,…>

注意:泛型類型必須是引用類型

泛型方法

把泛型定義在方法上

格式:public <泛型類型> 返回類型 方法名(泛型類型 .)

泛型接口

把泛型定義在接口上

格式:public  interface 接口名<泛型類型1…>

泛型之通配符

l  泛型通配符<?>

    任意類型，若是沒有明確，那麼就是Object以及任意的Java類了

l  ? extends E

    向下限定，E及其子類

l  ? super E

    向上限定，E及其父類

1.1.4       Set接口

一個不包含重複元素的collection

l HashSet類概述

    不保證 set 的迭代順序

    特別是它不保證該順序恆久不變。

l  HashSet如何保證元素惟一性

    底層數據結構是哈希表(元素是鏈表的數組)

    哈希表依賴於哈希值存儲

    添加功能底層依賴兩個方法：

l  int hashCode()

l  boolean equals(Object obj)

執行順序：

                首先比較哈希值是否相同:

                                   相同：繼續執行equals()方法

                                            返回true：元素重複了，不添加

                                            返回false：直接把元素添加到集合

                                   不一樣：就直接把元素添加到集合

l  LinkedHashSet類概述

    元素有序惟一

    由鏈表保證元素有序

    由哈希表保證元素惟一

l  TreeSet類概述

    使用元素的天然順序對元素進行排序

    或者根據建立 set 時提供的 Comparator進行排序

a:天然排序(元素具有比較性)

                               讓元素所屬的類實現Comparable接口

b:比較器排序(集合具有比較性)

                               讓集合構造方法接收Comparator的實現類對象

    具體取決於使用的構造方法。

l  TreeSet是如何保證元素的排序和惟一性的

    底層數據結構是紅黑樹(紅黑樹是一種自平衡的二叉樹)

1.1.5       Collection總結：

Collection:

         |--List有序，可重複

                   |--ArrayList:底層是數組，查詢快，增刪慢；線程不安全；

                   |--Vector:底層是數組，查詢快，增刪慢；線程安全；

                   |--LinkedList:底層是鏈表，查詢慢，增刪快；線程不安全；

         |--Set無序或有序，惟一

                   |--HashSet:底層是哈希表；依賴hashCode和equals方法保證元素惟一（開發中自動生成這兩個方法便可）

                            |--LinkedHashSet:底層是鏈表和哈希表，由鏈表保證元素有序，由哈希表保證惟一

                   |--TreeSet:底層是紅黑樹（一種自平衡的二叉樹），由天然排序和比較器排序保證元素有序；根據比較的返回值是不是0決定惟一。

到底使用誰？

惟一嗎?

                   是：Set

                            排序嗎?

                                     是：TreeSet

                                     否：HashSet

                   若是你知道是Set，可是不知道是哪一個Set，就用HashSet。

                           

                   否：List

                            要安全嗎?

                                     是：Vector

                                     否：ArrayList或者LinkedList

                                               查詢多：ArrayList

                                               增刪多：LinkedList

                   若是你知道是List，可是不知道是哪一個List，就用ArrayList。

        

         若是你知道是Collection集合，可是不知道使用誰，就用ArrayList。

        

         若是你知道用集合，就用ArrayList

1.2     Map接口

• 將鍵映射到值的對象；一個映射不能包含重複的鍵；每一個鍵最多隻能映射到一個值。

Map和Collection的區別：

1，Map是雙列的,Collection是單列的

2，Map的鍵惟一,Collection的子體系Set是惟一的

3，Map集合的數據結構值針對鍵有效，跟值無關

4，Collection集合的數據結構是針對元素有效

• Map接口成員方法

V put(K key,V value)

V remove(Object key)

void clear()

boolean containsKey(Object key)

boolean containsValue(Object value)

boolean isEmpty()

int size()

 

V get(Object key)

Set<K> keySet()

Collection<V> values()

Set<Map.Entry<K,V>> entrySet()

 

l HashMap類概述

    鍵是哈希表結構，能夠保證鍵的惟一性

   LinkedHashMap  :Map 接口的哈希表和連接列表實現，具備可預知的迭代順序

l  TreeMap類概述

    鍵是紅黑樹結構，能夠保證鍵的排序和惟一性

遍歷MAP以及效率比對

   

咱們都知道遍歷Map通常有3種方法，values()，keySet()和entrySet()，常見的是keySet用的多，簡單容易理解，entrySet()是返回Map中的靜態內部類Entry類類型的Set實例，固然了你別說forEach，forEach只是一種代替for(int i=0;;)和while()遍歷的一種方式，底層也是用迭代器實現的,只不過把部分東西隱藏了,建議你們日常開發中能用forEach遍歷,儘量的用這個,《Effective java》中也明確表示了，簡單而不容易出錯。

若是Map中有大量的元素，並且併發量又很高，這就涉及到採用哪一種遍歷方法的問題，下面就來測試一下：

[java] view plain copy

 Map<String,String>mapTest=new HashMap<String,String>(); 

    for(int i=0;i<10000;i++){ 

       mapTest.put(String.valueOf(i),String.valueOf(i) ); 

    } 

 

    //一種遍歷，keySet()方法 

    longstart=System.nanoTime(); 

    Set<String>setEach=mapTest.keySet(); 

    for(String key:setEach){ 

        String value=mapTest.get(key); 

    } 

    long end=System.nanoTime(); 

    System.out.println("keySet遍歷map耗時"+(end-start)/1000+"微秒"); 

[java] view plain copy

//二種遍歷，可用values()返回Collection<T>,不容易獲得對應的key 

    start=System.nanoTime(); 

    Collection<String>co=mapTest.values(); 

    for(String value:co){ 

        //遍歷中也在建立value 

    } 

    end=System.nanoTime(); 

    System.out.println("values遍歷map(只獲得值)耗時"+(end-start)/1000+"微秒"); 

[java] view plain copy

//三種遍歷，用entrySet()方法返回Set<Map.Entry<T,T>>類型，再獲取裏邊的Map.Entry 

    start=System.nanoTime(); 

    Set<Map.Entry<String,String>>entrySet=mapTest.entrySet(); 

    for(Map.Entry<String,String> entry:entrySet){ 

        String key=entry.getKey(); 

        String value=entry.getValue(); 

    } 

    end=System.nanoTime(); 

    System.out.println("entrySet遍歷map耗時"+(end-start)/1000+"微秒"); 

通過屢次運行，結果大概都是這樣的：

[java] view plain copy

    keySet遍歷map耗時9867微秒 

    values遍歷map(只獲得值)耗時2539微秒 

    entrySet遍歷map耗時2783微秒 

  values()是返回Map的全部value的集合collection,只能遍歷到值，很難遍歷到key因此通常不用，除非在某種特殊場合，因此通常採用的第一種和第三種方式。而測試代表entrySet()方式遍歷效率更高。

      entrySet()方式遍歷之因此快與keySet()，一個緣由是keySet至關與遍歷了2次，一次是對key的Set集合的遍歷，二次是每次遍歷過程都要經過key和map.get(key)來獲取value值。第二個緣由是map.get(key)獲取的時候，底層其實根據key的hashcode值通過哈希算法獲得一個hash值而後做爲索引映射到對應table數組的索引位置，這是一次密集型計算，很耗費CPU，若是有大量的元素，則會使CPU使用率飆升，影響響應速度，而entrySet()返回的set裏邊元素都是Map.Entry類型，key和value就是這個類的一個屬性，entry.getKey()和entry.getValue()效率確定很高。

       因此日常開發過程當中，若是對Map講究效率的遍歷的話，仍是採用entrySet()方法。

 

1.3     Collections類

Collections類概述

針對集合操做 的工具類

Collections成員方法

public static<T> void sort(List<T> list)

public static<T> int binarySearch(List<?> list,T key)

public static<T> T max(Collection<?> coll)

public staticvoid reverse(List<?> list)

public staticvoid shuffle(List<?> list)

2.     IO流

IO流用來處理設備之間的數據傳輸

上傳文件和下載文件

Java對數據的操做是經過流的方式

Java用於操做流的對象都在IO包中

2.1     File類

File類的概述

文件和目錄路徑名的抽象表示形式

構造方法

public File(String pathname)

public File(String parent,String child)

public File(File parent,String child)

 

2.2     遞歸

遞歸

方法定義中調用方法自己的現象

遞歸注意實現

要有出口，不然就是死遞歸

次數不能太多，不然就內存溢出

構造方法不能遞歸使用

遞歸解決問題的思想

找到出口

找到規律

 

2.3     IO流分類

按照數據流向

輸入流     讀入數據

輸出流     寫出數據

按照數據類型

字節流

字符流

什麼狀況下使用哪一種流呢?

若是數據所在的文件經過windows自帶的記事本打開並能讀懂裏面的內容，就用字符流。其餘用字節流。

若是你什麼都不知道，就用字節流

IO流經常使用基類

l  字節流的抽象基類：

    InputStream ，OutputStream。

l  字符流的抽象基類：

    Reader ， Writer。

l  注：由這四個類派生出來的子類名稱都是以其父類名做爲子類名的後綴。

    如：InputStream的子類FileInputStream。

    如：Reader的子類FileReader。

2.4     IO讀寫數據

FileOutputStream寫出數據

                   A:操做步驟

                            a:建立字節輸出流對象

                            b:調用write()方法

                            c:釋放資源

                           

                   B:代碼體現：

                            FileOutputStreamfos = new FileOutputStream("fos.txt");

                           

                            fos.write("hello".getBytes());

                           

                            fos.close();

                           

                   C:要注意的問題?

                            a:建立字節輸出流對象作了幾件事情?

                            b:爲何要close()?

                            c:如何實現數據的換行?

                            d:如何實現數據的追加寫入?

FileInputStream讀取數據

                   A:操做步驟

                            a:建立字節輸入流對象

                            b:調用read()方法

                            c:釋放資源

                           

                   B:代碼體現：

                            FileInputStreamfis = new FileInputStream("fos.txt");

                           

                            //方式1

                            intby = 0;

                            while((by=fis.read())!=-1){

                                     System.out.print((char)by);

                            }

                           

                            //方式2

                            byte[]bys = new byte[1024];

                            intlen = 0;

                            while((len=fis.read(bys))!=-1){

                                     System.out.print(newString(bys,0,len));

                            }

                           

                            fis.close();

字節緩衝區流

                   A:BufferedOutputStream

                   B:BufferedInputStream

2.5     轉換流

因爲字節流操做中文不是特別方便，因此，java就提供了轉換流。

字符流=字節流+編碼表。

2.5.1       編碼表

• 編碼表

由字符及其對應的數值組成的一張表

常見編碼表

ASCII： 字符集 美國標準信息交換碼。用一個字節的7位能夠表示。

ISO-8859-1： 拉丁碼錶。歐洲碼錶；用一個字節的8位表示。

GB2312：中國的中文編碼表。

GBK：中國的中文編碼表升級，融合了更多的中文文字符號。

GB18030：GBK的取代版本

BIG5：通行於臺灣、香港地區的一個繁體字編碼方案，俗稱「大五碼」

Unicode：國際標準碼，融合了多種文字。全部文字都用兩個字節來表示,Java語言使用的就是unicode

UTF-8：最多用三個字節來表示一個字符

UTF-8不一樣，它定義了一種「區間規則」，這種規則能夠和ASCII編碼保持最大程度的兼容：

它將Unicode編碼爲00000000-0000007F的字符，用單個字節來表示
它將Unicode編碼爲00000080-000007FF的字符用兩個字節表示 
它將Unicode編碼爲00000800-0000FFFF的字符用3字節表示

• 字符串中的編碼問題

                            編碼

                                     String-- byte[]

                            解碼

                                     byte[]-- String

2.5.2       轉換流概述

A:OutputStreamWriter

                            OutputStreamWriter(OutputStreamos):默認編碼，GBK

                            OutputStreamWriter(OutputStreamos,String charsetName):指定編碼。

B:InputStreamReader

                            InputStreamReader(InputStreamis):默認編碼，GBK

                            InputStreamReader(InputStreamis,String charsetName):指定編碼默認編碼

字符流

                   Reader

                            |--InputStreamReader

                                     |--FileReader

                            |--BufferedReader

                   Writer

                            |--OutputStreamWriter

                                     |--FileWriter

                            |--BufferedWriter

2.6     IO流總結：

IO流

                   |--字節流

                            |--字節輸入流

                                     InputStream

                                               intread():一次讀取一個字節

                                               intread(byte[] bys):一次讀取一個字節數組

                                    

                                               |--FileInputStream

                                               |--BufferedInputStream

                            |--字節輸出流

                                     OutputStream

                                               voidwrite(int by):一次寫一個字節

                                               voidwrite(byte[] bys,int index,int len):一次寫一個字節數組的一部分

                                              

                                               |--FileOutputStream

                                               |--BufferedOutputStream

                   |--字符流

                            |--字符輸入流

                                     Reader

                                               intread():一次讀取一個字符

                                               intread(char[] chs):一次讀取一個字符數組

                                              

                                               |--InputStreamReader

                                                        |--FileReader

                                               |--BufferedReader

                                                        StringreadLine():一次讀取一個字符串

                            |--字符輸出流

                                     Writer

                                               voidwrite(int ch):一次寫一個字符

                                               voidwrite(char[] chs,int index,int len):一次寫一個字符數組的一部分

                                              

                                               |--OutputStreamWriter

                                                        |--FileWriter

                                               |--BufferedWriter

                                                        voidnewLine():寫一個換行符

                                                       

                                                        voidwrite(String line):一次寫一個字符串

3.     其餘操做流

1：數據操做流(操做基本類型數據的流)(理解)

         (1)能夠操做基本類型的數據

         (2)流對象名稱        

                   DataInputStream

                   DataOutputStream

 

2:內存操做流(理解)

         (1)有些時候咱們操做完畢後，未必須要產生一個文件，就可使用內存操做流。

         (2)三種

                   A:ByteArrayInputStream,ByteArrayOutputStream

                  B:CharArrayReader,CharArrayWriter

                   C:StringReader,StringWriter

 

3:打印流(掌握)

         (1)字節打印流，字符打印流

         (2)特色：

                   A:只操做目的地,不操做數據源

                   B:能夠操做任意類型的數據

                   C:若是啓用了自動刷新，在調用println()方法的時候，可以換行並刷新

                   D:能夠直接操做文件

                            問題：哪些流能夠直接操做文件呢?

                            看API，若是其構造方法可以同時接收File和String類型的參數，通常都是能夠直接操做文件的

         (3)複製文本文件

                   BufferedReaderbr = new BufferedReader(new FileReader("a.txt"));

                   PrintWriterpw = new PrintWriter(new FileWriter("b.txt"),true);

                  

                   Stringline = null;

                   while((line=br.readLine())!=null){

                            pw.println(line);

                   }

                  

                  pw.close();

                   br.close();

                           

4:標準輸入輸出流(理解)

         (1)System類下面有這樣的兩個字段

                   in標準輸入流

                   out標準輸出流

         (2)三種鍵盤錄入方式

                   A:main方法的args接收參數

                   B:System.in經過BufferedReader進行包裝

                            BufferedReaderbr = new BufferedReader(new InputStreamReader(System.in));

                   C:Scanner

                            Scannersc = new Scanner(System.in);

         (3)輸出語句的原理和如何使用字符流輸出數據

                   A:原理

                            System.out.println("helloworld");

                           

                            PrintStreamps = System.out;

                            ps.println("helloworld");

                   B:把System.out用字符緩衝流包裝一下使用

                            BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(System.out));

 

5:隨機訪問流(理解)

         (1)能夠按照文件指針的位置寫數據和讀數據。

         (2)案例：

                   A:寫數據

                   B:讀數據

                   C:獲取和改變文件指針的位置

 

6:合併流(理解)

         (1)把多個輸入流的數據寫到一個輸出流中。

         (2)構造方法：

                   A:SequenceInputStream(InputStreams1, InputStream s2)

                   B:SequenceInputStream(Enumeration<?extends InputStream> e)

 

7:序列化流(理解)

         (1)能夠把對象寫入文本文件或者在網絡中傳輸

         (2)如何實現序列化呢?

                   讓被序列化的對象所屬類實現序列化接口。

                   該接口是一個標記接口。沒有功能須要實現。

         (3)注意問題：

                   把數據寫到文件後，在去修改類會產生一個問題。

                   如何解決該問題呢?

                            在類文件中，給出一個固定的序列化id值。

                            並且，這樣也能夠解決×××警告線問題

 

8:Properties(理解)

         (1)是一個集合類，Hashtable的子類

         (2)特有功能

                   A:publicObject setProperty(String key,String value)

                   B:publicString getProperty(String key)

                   C:publicSet<String> stringPropertyNames()

         (3)和IO流結合的方法

                   把鍵值對形式的文本文件內容加載到集合中

                   publicvoid load(Reader reader)

                   publicvoid load(InputStream inStream)

 

                   把集合中的數據存儲到文本文件中

                   publicvoid store(Writer writer,String comments)

                   publicvoid store(OutputStream out,String comments)

 

10:NIO(瞭解)

         (1)JDK4出現的NIO，對之前的IO操做進行了優化，提供了效率。可是大部分咱們看到的仍是之前的IO

         (2)JDK7的NIO的使用  

Path:與平臺無關的路徑。

Paths:包含了返回Path的靜態方法。

         publicstatic Path get(URI uri):根據給定的URI來肯定文件路徑。

Files:操做文件的工具類。提供了大量的方法，簡單瞭解以下方法

         publicstatic long copy(Path source,OutputStream out):複製文件

         publicstatic Path write(Path path,Iterable<?extends CharSequence> lines,Charset cs,OpenOption... options):

                   把集合的數據寫到文件。

//複製文件

Files.copy(Paths.get("Demo.java"),newFileOutputStream("Copy.Java"));

//把集合中的數據寫到文件

List<String> list = newArrayList<String>();

list.add("hello");

list.add("world");

list.add("java");

Files.write(Paths.get("list.txt"),list, Charset.forName("gbk"));

 

4.     異常

4.1     異常概述：

異常就是Java程序在運行過程當中出現的錯誤。

異常由來：問題也是現實生活中一個具體事務，也能夠經過java 的類的形式進行描述，並封裝成對象。其實就是Java對不正常狀況進行描述後的對象體現。

4.2     異常分類圖：

4.3     異常的體系

                   Throwable

                            |--Error    嚴重問題，咱們不處理。

                            |--Exception

                                     |--RuntimeException        運行期異常，咱們須要修正代碼

                                     |--非RuntimeException編譯期異常，必須處理的，不然程序編譯不經過

異常分三類：

騎車去旅行：

         Error:走到半路上，發生山路塌陷，或者出現了泥石流，這個問題很嚴重，不是班長可以立馬解決的。

         Exception:出門前，班長要看看車輪子以及車鏈子等是否還在

         RuntimeException:在騎車的過程當中，有好路不走，恰恰要走石子路

1,編譯時異常

除了RuntimeException及其子類,Exception中全部的子類都是,這種異常必需要處理,要不編譯通不過

2,運行時異常

RuntimeException及其子類都是,這種異常不用處理,編譯會經過,不過這樣的程序會有安全隱患,遇到這種異常是須要改代碼的

3,嚴重錯誤問題

用Error進行描述,這個問題發生後,通常不編寫針對代碼進行處理,而是要對程序進行修正.一般都是由虛擬機拋出的問題

4.4     異常的處理：

                   A:JVM的默認處理

                            把異常的名稱,緣由,位置等信息輸出在控制檯，可是呢程序不能繼續執行了。

                   B:本身處理

                            a:try...catch...finally

                                     本身編寫處理代碼,後面的程序能夠繼續執行

                            b:throws

                                     把本身處理不了的，在方法上聲明，告訴調用者，這裏有問題

4.5     finally

finally的特色

被finally控制的語句體必定會執行

特殊狀況：在執行到finally以前jvm退出了(好比System.exit(0))

finally的做用

用於釋放資源，在IO流操做和數據庫操做中會見到

 

4.6     自定義異常

                   繼承自Exception或者RuntimeException,只須要提供無參構造和一個帶參構造便可

異常的注意實現

                   A:父的方法有異常拋出,子的重寫方法在拋出異常的時候必需要小於等於父的異常

                   B:父的方法沒有異常拋出,子的重寫方法不能有異常拋出

                   C:父的方法拋出多個異常,子的重寫方法必須比父少或者小

4.7     異常類

• ConcurrentModificationException異常

併發修改異常

                   A:出現的現象

                            迭代器遍歷集合，集合修改集合元素

                   B:緣由

                            迭代器是依賴於集合的，而集合的改變迭代器並不知道。

                   C:解決方案

                            a:迭代器遍歷，迭代器修改(ListIterator)

                                     元素添加在剛纔迭代的位置

                            b:集合遍歷，集合修改(size()和get())

                                     元素添加在集合的末尾

• ArithmeticException數學運算異常

•      面試題

•      HashMap和Hashtable的區別：

1、HashMap是非線程安全的，HashTable是線程安全的。

2、HashMap的鍵和值都容許有null值存在，而HashTable則不行。

3、由於線程安全的問題，HashMap效率比HashTable的要高。

 

5.2     List,Set,Map等接口是否都繼承子Map接口：不是！

5.3     Collection和Collections的區別

                   A:Collection是單列集合的頂層接口，有兩個子接口List和Set

                   B:Collections是針對集合進行操做的工具類，能夠對集合進行排序和查找等

5.4     編譯期異常和運行期異常的區別?

                            編譯期異常 必需要處理的，不然編譯不經過

                            運行期異常 能夠不處理，也能夠處理

5.5     throw和throws的區別

• throws

  用在方法聲明後面，跟的是異常類名

  能夠跟多個異常類名，用逗號隔開

  表示拋出異常，由該方法的調用者來處理

  throws表示出現異常的一種可能性，並不必定會發生這些異常

• throw

   用在方法體內，跟的是異常對象名

   只能拋出一個異常對象名

   表示拋出異常，由方法體內的語句處理

   throw則是拋出了異常，執行throw則必定拋出了某種異常

5.6     final,finally,finalize的區別?

百度

5.7     若是catch裏面有return語句，請問finally的代碼還會執行嗎?若是會，請問是在return前仍是return後。

會，前。

5.8     面試題：

                   何時序列化?

                   如何實現序列化?

                   什麼是反序列化?

對象序列化是將對象狀態轉換爲可保持或傳輸的過程。通常的格式是與平臺無關的二進制流，能夠將這種二進制流持久保存在磁盤上，也能夠經過網絡將這種二進制流傳輸到另外一個網絡結點。

對象反序列化，是指把這種二進制流數據還原成對象。

java基礎系列：

java基礎（一）java語法

java基礎（二）面向對象

java基礎（三）繼承/多態/接口

java基礎（四）經常使用類/算法

java基礎（五）集合/IO流/異常

java基礎（六）多線程/設計模式

java基礎（七）網絡編程/反射/動態代理