java基礎知識（一）

時間 2019-11-08

標籤 java 基礎知識欄目 Java 简体版

原文原文鏈接

1、Java 面向對象

1面向對象都有哪些特性以及對這些特性的理解

1）繼承：繼承是從已有類獲得繼承信息建立新類的過程。提供繼承信息的類被稱爲父類（超類、基類）；獲得繼承信息的類被稱爲子類（派生類）。繼承讓變化中的軟件系統有了必定的延續性，同時繼承也是封裝程序中可變因素的重要手段；java

2）封裝：一般認爲封裝是把數據和操做數據的方法綁定起來，對數據的訪問只能經過已定義的接口。面向對象的本質就是將現實世界描繪成一系列徹底自治、封閉的對象。咱們在類中編寫的方法就是對實現細節的一種封裝；咱們編寫一個類就是對數據和數據操做的封裝。能夠說，封裝就是隱藏一切可隱藏的東西，只向外界提供最簡單的編程接口；程序員

3）多態性：多態性是指容許不一樣子類型的對象對同一消息做出不一樣的響應。簡單的說就是用一樣的對象引用調用一樣的方法可是作了不一樣的事情。多態性分爲編譯時的多態性和運行時的多態性。若是將對象的方法視爲對象向外界提供的服務，那麼運行時的多態性能夠解釋爲：當 A 系統訪問 B 系統提供的服務時，B 系統有多種提供服務的方式，但一切對 A 系統來講都是透明的。方法重載（overload）實現的是編譯時的多態性（也稱爲前綁定），而方法重寫（override）實現的是運行時的多態性（也稱爲後綁定）。運行時的多態是面向對象最精髓的東西，要實現多態須要作兩件事：1. 方法重寫（子類繼承父類並重寫父類中已有的或抽象的方法）；2. 對象造型（用父類型引用引用子類型對象，這樣一樣的引用調用一樣的方法就會根據子類對象的不一樣而表現出不一樣的行爲）；面試

4）抽象：抽象是將一類對象的共同特徵總結出來構造類的過程，包括數據抽象和行爲抽象兩方面。抽象只關注對象有哪些屬性和行爲，並不關注這些行爲的細節是什麼。數據庫

注意：默認狀況下面向對象有 3 大特性，封裝、繼承、多態。編程

2. 訪問權限修飾符 public、private、protected, 以及不寫（默認）時的區別以下圖

2、JavaSE 語法

1. Java 有沒有 goto 語句？

goto 是 Java 中的保留字，在目前版本的 Java 中沒有使用。根據 James Gosling（Java 之父）編寫的《The Java Programming Language》一書的附錄中給出了一個 Java 關鍵字列表，其中有 goto 和 const，可是這兩個是目前沒法使用的關鍵字，所以有些地方將其稱之爲保留字，其實保留字這個詞應該有更普遍的意義，由於熟悉 C 語言的程序員都知道，在系統類庫中使用過的有特殊意義的單詞或單詞的組合都被視爲保留字。數組

2. & 和 && 的區別

&運算符有兩種用法：(1)按位與；(2)邏輯與。緩存

&&運算符是短路與運算。邏輯與跟短路與的差異是很是巨大的，雖然兩者都要求運算符左右兩端的布爾值都是true 整個表達式的值纔是 true。&&之因此稱爲短路運算是由於，若是&&左邊的表達式的值是 false，右邊的表達式會被直接短路掉，不會進行運算。不少時候咱們可能都須要用&&而不是&，例如在驗證用戶登陸時斷定用戶名不是 null 並且不是空字符串，應當寫爲 username != null &&!username.equals("")，兩者的順序不能交換，更不能用&運算符，由於第一個條件若是不成立，根本不能進行字符串的 equals 比較，不然會產生 NullPointerException 異常。注意：邏輯或運算符（|）和短路或運算符（||）的差異也是如此。安全

3. 在 Java 中，如何跳出當前的多重嵌套循環

在最外層循環前加一個標記如 A，而後用 break A;能夠跳出多重循環。（Java 中支持帶標籤的 break 和 continue 語句，做用有點相似於 C 和 C++中的 goto 語句，可是就像要避免使用 goto 同樣，應該避免使用帶標籤的 break 和 continue，由於它不會讓你的程序變得更優雅，不少時候甚至有相反的做用）。網絡

4. 兩個對象值相同 (x.equals(y) == true) ，但卻可有不一樣的 hashCode，這句話對不對？

不對，若是兩個對象 x 和 y 知足 x.equals(y) == true，它們的哈希碼（hashCode）應當相同。Java 對於 eqauls 方法和 hashCode 方法是這樣規定的：(1)若是兩個對象相同（equals 方法返回 true），那麼它們的 hashCode 值必定要相同；(2)若是兩個對象的 hashCode 相同，它們並不必定相同。固然，你未必要按照要求去作，可是若是你違背了上述原則就會發如今使用容器時，相同的對象能夠出如今 Set 集合中，同時增長新元素的效率會大大降低（對於使用哈希存儲的系統，若是哈希碼頻繁的衝突將會形成存取性能急劇降低）。數據結構

關於 equals 和 hashCode 方法，不少 Java 程序員都知道，但不少人也就是僅僅知道而已，在 Joshua Bloch的大做《Effective Java》（不少軟件公司，《Effective Java》、《Java 編程思想》以及《重構：改善既有代碼質量》是 Java 程序員必看書籍，若是你還沒看過，那就趕忙去買一本吧）中是這樣介紹 equals 方法的。首先 equals 方法必須知足自反性（x.equals(x)必須返回 true）、對稱性（x.equals(y)返回 true 時，y.equals(x)也必須返回 true）、傳遞性（x.equals(y)和 y.equals(z)都返回 true 時，x.equals(z)也必須返回 true）和一致性（當x 和 y 引用的對象信息沒有被修改時，屢次調用 x.equals(y)應該獲得一樣的返回值），並且對於任何非 null 值的引用 x，x.equals(null)必須返回 false。實現高質量的 equals 方法的訣竅包括：1. 使用==操做符檢查"參數是否爲這個對象的引用"；2. 使用 instanceof 操做符檢查"參數是否爲正確的類型"；3. 對於類中的關鍵屬性，檢查參數傳入對象的屬性是否與之相匹配；4. 編寫完 equals 方法後，問本身它是否知足對稱性、傳遞性、一致性；5. 重寫 equals 時老是要重寫 hashCode；6. 不要將 equals 方法參數中的 Object 對象替換爲其餘的類型，在重寫時不要忘掉@Override 註解。

5. 是否能夠繼承 String

String 類是 final 類，不能夠被繼承。

繼承 String 自己就是一個錯誤的行爲，對 String 類型最好的重用方式是關聯關係（Has-A）和依賴關係（UseA）而不是繼承關係（Is-A）。

6. 當一個對象被看成參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裏究竟是值傳遞仍是引用傳遞?

是值傳遞。Java 語言的方法調用只支持參數的值傳遞。當一個對象實例做爲一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的屬性能夠在被調用過程當中被改變，但對對象引用的改變是不會影響到調用者的。C++和 C#中能夠經過傳引用或傳輸出參數來改變傳入的參數的值。說明：Java 中沒有傳引用實在是很是的不方便，這一點在 Java 8 中仍然沒有獲得改進，正是如此在 Java 編寫的代碼中才會出現大量的 Wrapper 類（將須要經過方法調用修改的引用置於一個 Wrapper 類中，再將 Wrapper 對象傳入方法），這樣的作法只會讓代碼變得臃腫，尤爲是讓從 C 和 C++轉型爲 Java 程序員的開發者沒法容忍。

7. 重載（overload）和重寫（override）的區別？重載的方法可否根據返回類型進行區分？

方法的重載和重寫都是實現多態的方式，區別在於前者實現的是編譯時的多態性，然後者實現的是運行時的多態性。重載發生在一個類中，同名的方法若是有不一樣的參數列表（參數類型不一樣、參數個數不一樣或者兩者都不一樣）則視爲重載；重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型，比父類被重寫方法更好訪問，不能比父類被重寫方法聲明更多的異常（里氏代換原則）。重載對返回類型沒有特殊的要求。

方法重載的規則：1.方法名一致，參數列表中參數的順序，類型，個數不一樣。

　　　　　　　　2.重載與方法的返回值無關，存在於父類和子類，同類中。

　　　　　　　　3.能夠拋出不一樣的異常，能夠有不一樣修飾符。

方法重寫的規則：1.參數列表必須徹底與被重寫方法的一致，返回類型必須徹底與被重寫方法的返回類型一致。
　　　　　　　　2.構造方法不能被重寫，聲明爲 final 的方法不能被重寫，聲明爲 static 的方法不能被重寫，可是可以被再次聲明。

　　　　　　　　3.訪問權限不能比父類中被重寫的方法的訪問權限更低。

　　　　　　　　4.重寫的方法可以拋出任何非強制異常（UncheckedException，也叫非運行時異常），不管被重寫的方法是否拋出異常。可是，重寫的方法不能拋出新的強制性異常，或者比被重寫方法聲明的更普遍的強制性異常，反之能夠。

8. char 型變量中能不能存儲一箇中文漢字，爲何？

char 類型能夠存儲一箇中文漢字，由於 Java 中使用的編碼是 Unicode（不選擇任何特定的編碼，直接使用字符在字符集中的編號，這是統一的惟一方法），一個 char 類型佔 2 個字節（16 比特），因此放一箇中文是沒問題的。

補充：使用 Unicode 意味着字符在 JVM 內部和外部有不一樣的表現形式，在 JVM 內部都是 Unicode，當這個字符被從 JVM 內部轉移到外部時（例如存入文件系統中），須要進行編碼轉換。因此 Java 中有字節流和字符流，以及在字符流和字節流之間進行轉換的轉換流，如 InputStreamReader 和 OutputStreamReader，這兩個類是字節流和字符流之間的適配器類，承擔了編碼轉換的任務；對於 C 程序員來講，要完成這樣的編碼轉換恐怕要依賴於 union（聯合體/共用體）共享內存的特徵來實現了。

9.Java 中的反射

Java 中的反射首先是能夠獲取到 Java 中要反射類的字節碼，獲取字節碼有三種方法，

1.Class.forName(className)

2.類名.class

3.this.getClass()。

而後將字節碼中的方法，變量，構造函數等映射成相應的 Method、Filed、Constructor 等類，這些類提供了豐富的方法能夠被咱們所使用。

10. 抽象類(abstract class)和接口(interface)有什麼異同？

抽象類：抽象類是用來捕捉子類的通用特性的。它不能被實例化，只能被用做子類的超類。抽象類是被用來建立繼承層級裏子類的模板。

接口：接口是抽象方法的集合。若是一個類實現了某個接口，那麼它就繼承了這個接口的抽象方法。這就像契約模式，若是實現了這個接口，那麼就必須確保使用這些方法。接口只是一種形式，接口自身不能作任何事情。　　　　　　

一、抽象類和接口都不能直接實例化，若是要實例化，抽象類變量必須指向實現全部抽象方法的子類對象，接口變量必須指向實現全部接口方法的類對象。

二、抽象類要被子類繼承，接口要被類實現。

三、接口只能作方法申明，抽象類中能夠作方法申明，也能夠作方法實現

四、接口裏定義的變量只能是公共的靜態的常量，抽象類中的變量是普通變量。

五、抽象類裏的抽象方法必須所有被子類所實現，若是子類不能所有實現父類抽象方法，那麼該子類只能是抽象類。一樣，一個實現接口的時候，如不能所有實現接口方法，那麼該類也只能爲抽象類。

六、抽象方法只能申明，不能實現，接口是設計的結果，抽象類是重構的結果

七、抽象類裏能夠沒有抽象方法

八、若是一個類裏有抽象方法，那麼這個類只能是抽象類

九、抽象方法要被實現，因此不能是靜態的，也不能是私有的。

十、接口可繼承接口，並可多繼承接口，但類只能單根繼承。

若是你擁有一些方法而且想讓它們中的一些有默認實現，那麼使用抽象類吧。

若是你想實現多重繼承，那麼你必須使用接口。因爲Java不支持多繼承，子類不可以繼承多個類，但能夠實現多個接口。所以你就可使用接口來解決它。

若是基本功能在不斷改變，那麼就須要使用抽象類。若是不斷改變基本功能而且使用接口，那麼就須要改變全部實現了該接口的類。

11. 抽象的(abstract)方法是否可同時是靜態的(static), 是否可同時是本地方法(native)，是否可同時被 synchronized

都不能。抽象方法須要子類重寫，而靜態的方法是沒法被重寫的，所以兩者是矛盾的。本地方法是由本地代碼（如 C 代碼）實現的方法，而抽象方法是沒有實現的，也是矛盾的。synchronized 和方法的實現細節有關，抽象方法不涉及實現細節，所以也是相互矛盾的。

12. 闡述靜態變量和實例變量的區別？

靜態變量: 是被 static 修飾符修飾的變量，也稱爲類變量，它屬於類，不屬於類的任何一個對象，一個類無論建立多少個對象，靜態變量在內存中有且僅有一個拷貝；

實例變量: 必須依存於某一實例，須要先建立對象而後經過對象才能訪問到它。靜態變量能夠實現讓多個對象共享內存。

13. ==和 equals 的區別？

equals 和== 最大的區別是一個是方法一個是運算符。

==：若是比較的對象是基本數據類型，則比較的是數值是否相等；若是比較的是引用數據類型，則比較的是對象的地址值是否相等。

equals()：用來比較方法兩個對象的內容是否相等。注意：equals 方法不能用於基本數據類型的變量，若是沒有對 equals 方法進行重寫，則比較的是引用類型的變量所指向的對象的地址。

14. break 和 continue 的區別？

break 和 continue 都是用來控制循環的語句。break 用於徹底結束一個循環，跳出循環體執行循環後面的語句。continue 用於跳過本次循環，執行下次循環。

15. String s = "Hello";s = s + " world!";這兩行代碼執行後，原始的 String 對象中的內容到底變了沒有？

沒有。由於 String 被設計成不可變(immutable)類，因此它的全部對象都是不可變對象。在這段代碼中，s 原先指向一個 String 對象，內容是 "Hello"，而後咱們對 s 進行了「+」操做，那麼 s 所指向的那個對象是否發生了改變呢？答案是沒有。這時，s 不指向原來那個對象了，而指向了另外一個 String 對象，內容爲"Hello world!"，原來那個對象還存在於內存之中，只是 s 這個引用變量再也不指向它了。

經過上面的說明，咱們很容易導出另外一個結論，若是常常對字符串進行各類各樣的修改，或者說，不可預見的修改，那麼使用 String 來表明字符串的話會引發很大的內存開銷。由於 String 對象創建以後不能再改變，因此對於每個不一樣的字符串，都須要一個 String 對象來表示。這時，應該考慮使用 StringBuffer 類，它容許修改，而不是每一個不一樣的字符串都要生成一個新的對象。而且，這兩種類的對象轉換十分容易。同時，咱們還能夠知道，若是要使用內容相同的字符串，沒必要每次都 new 一個 String。例如咱們要在構造器中對一個名叫 s 的 String 引用變量進行初始化，把它設置爲初始值，應當這樣作：

1．public class Demo { 2． 　　private String s; 3． 　　... 4．　　 s = "Initial Value"; 5．　　 ... 6．}

而非　

1．s = new String("Initial Value");

後者每次都會調用構造器，生成新對象，性能低下且內存開銷大，而且沒有意義，由於 String 對象不可改變，因此對於內容相同的字符串，只要一個 String 對象來表示就能夠了。也就說，屢次調用上面的構造器建立多個對象，他們的 String 類型屬性 s 都指向同一個對象。

上面的結論還基於這樣一個事實：對於字符串常量，若是內容相同，Java 認爲它們表明同一個 String 對象。而用關鍵字 new 調用構造器，老是會建立一個新的對象，不管內容是否相同。至於爲何要把 String 類設計成不可變類，是它的用途決定的。其實不僅 String，不少 Java 標準類庫中的類都是不可變的。在開發一個系統的時候，咱們有時候也須要設計不可變類，來傳遞一組相關的值，這也是面向對象思想的體現。不可變類有一些優勢，好比由於它的對象是隻讀的，因此多線程併發訪問也不會有任何問題。固然也有一些缺點，好比每一個不一樣的狀態都要一個對象來表明，可能會形成性能上的問題。因此 Java 標準類庫還提供了一個可變版本，即 StringBuffer。

3、Java 中的多態

1. Java 中實現多態的機制是什麼？

靠的是父類或接口定義的引用變量能夠指向子類或具體實現類的實例對象，而程序調用的方法在運行期才動態綁定，就是引用變量所指向的具體實例對象的方法，也就是內存里正在運行的那個對象的方法，而不是引用變量的類型中定義的方法。

4、Java 的異常處理

1. Java 中異常分爲哪些種類

1）按照異常須要處理的時機分爲編譯時異常（也叫強制性異常）也叫 CheckedException 和運行時異常（也叫非強制性異常）也叫 RuntimeException。只有 java 語言提供了 Checked 異常，Java 認爲 Checked異常都是能夠被處理的異常，因此 Java 程序必須顯式處理 Checked 異常。若是程序沒有處理 Checked 異常，該程序在編譯時就會發生錯誤沒法編譯。這體現了 Java 的設計哲學：沒有完善錯誤處理的代碼根本沒有機會被執行。對 Checked 異常處理方法有兩種：

　　1 當前方法知道如何處理該異常，則用 try...catch 塊來處理該異常。

　　2 當前方法不知道如何處理，則在定義該方法是聲明拋出該異常。

運行時異常只有當代碼在運行時才發行的異常，編譯時不須要 try catch。Runtime 如除數是 0 和數組下標越界等，其產生頻繁，處理麻煩，若顯示申明或者捕獲將會對程序的可讀性和運行效率影響很大。因此由系統自動檢測並將它們交給缺省的異常處理程序。固然若是你有處理要求也能夠顯示捕獲它們。

2. 調用下面的方法，獲得的返回值是什麼？

1. public int getNum(){ 2.     try { 3.         int a = 1/0; 4.         return 1; 5.           } catch (Exception e) { 6.              return 2; 7.           }finally{ 8.             return 3; 9. }

代碼在走到第 3 行的時候遇到了一個 MathException，這時第四行的代碼就不會執行了，代碼直接跳轉到 catch語句中，走到第 6 行的時候，異常機制有這麼一個原則若是在 catch 中遇到了 return 或者異常等能使該函數終止的話那麼有 finally 就必須先執行完 finally 代碼塊裏面的代碼而後再返回值。所以代碼又跳到第 8 行，惋惜第 8 行是一個return 語句，那麼這個時候方法就結束了，所以第 6 行的返回結果就沒法被真正返回。若是 finally 僅僅是處理了一個釋放資源的操做，那麼該道題最終返回的結果就是 2。所以上面返回值是 3。

3. error 和 exception 的區別？

Error 類和 Exception 類的父類都是 Throwable 類，他們的區別以下。

Error 類通常是指與虛擬機相關的問題，如系統崩潰，虛擬機錯誤，內存空間不足，方法調用棧溢出等。對於這類錯誤的致使的應用程序中斷，僅靠程序自己沒法恢復和和預防，遇到這樣的錯誤，建議讓程序終止。

Exception 類表示程序能夠處理的異常，能夠捕獲且可能恢復。遇到這類異常，應該儘量處理異常，使程序恢復運行，而不該該隨意終止異常。

Exception 類又分爲運行時異常（Runtime Exception）和受檢查的異常(Checked Exception )，運行時異常;ArithmaticException,IllegalArgumentException，編譯能經過，可是一運行就終止了，程序不會處理運行時異常，出現這類異常，程序會終止。而受檢查的異常，要麼用 try。。。catch 捕獲，要麼用 throws 字句聲明拋出，交給它的父類處理，不然編譯不會經過。

4. java 異常處理機制

Java 對異常進行了分類，不一樣類型的異常分別用不一樣的 Java 類表示，全部異常的根類爲 java.lang.Throwable，Throwable 下面又派生了兩個子類：Error 和 Exception，Error 表示應用程序自己沒法克服和恢復的一種嚴重問題。Exception 表示程序還可以克服和恢復的問題，其中又分爲系統異常和普通異常，系統異常是軟件自己缺陷所致使的問題，也就是軟件開發人員考慮不周所致使的問題，軟件使用者沒法克服和恢復這種問題，但在這種問題下還可讓軟件系統繼續運行或者讓軟件死掉，例如，數組腳本越界（ArrayIndexOutOfBoundsException），空指針異常（NullPointerException）、類轉換異常（ClassCastException）；普通異常是運行環境的變化或異常所致使的問題，是用戶可以克服的問題，例如，網絡斷線，硬盤空間不夠，發生這樣的異常後，程序不該該死掉。

java 爲系統異常和普通異常提供了不一樣的解決方案，編譯器強制普通異常必須 try..catch 處理或用 throws 聲明繼續拋給上層調用方法處理，因此普通異常也稱爲 checked 異常，而系統異常能夠處理也能夠不處理，因此，編譯器不強制用 try..catch 處理或用 throws 聲明，因此係統異常也稱爲 unchecked 異常。

5. 最多見的RuntimeException

1）java.lang.NullPointerException 空指針異常；出現緣由：調用了未經初始化的對象或者是不存在的對象。

2）java.lang.ClassNotFoundException 指定的類找不到；出現緣由：類的名稱和路徑加載錯誤；一般都是程序試圖經過字符串來加載某個類時可能引起異常。

3）java.lang.NumberFormatException 字符串轉換爲數字異常；出現緣由：字符型數據中包含非數字型字符。

4）java.lang.IndexOutOfBoundsException 數組角標越界異常，常見於操做數組對象時發生。

5）java.lang.IllegalArgumentException 方法傳遞參數錯誤。

6）java.lang.ClassCastException 數據類型轉換異常。

7）java.lang.NoClassDefFoundException 未找到類定義錯誤。

8）SQLException SQL 異常，常見於操做數據庫時的 SQL 語句錯誤。

9）java.lang.InstantiationException 實例化異常。

10）java.lang.NoSuchMethodException 方法不存在異常。

6. throw 和 throws 的區別

throw：

　　　　1）throw 語句用在方法體內，表示拋出異常，由方法體內的語句處理。

　　　 2）throw 是具體向外拋出異常的動做，因此它拋出的是一個異常實例，執行 throw 必定是拋出了某種異常。

throws：

　　　　1）throws 語句是用在方法聲明後面，表示若是拋出異常，由該方法的調用者來進行異常的處理。

　　　　2）throws 主要是聲明這個方法會拋出某種類型的異常，讓它的使用者要知道須要捕獲的異常的類型。

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

7. final、finally、finalize 的區別？

1）final：用於聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，被其修飾的類不可繼承。

2）finally：異常處理語句結構的一部分，表示老是執行。

3）finalize：Object 類的一個方法，在垃圾回收器執行的時候會調用被回收對象的此方法，能夠覆蓋此方法提供垃圾收集時的其餘資源回收，例如關閉文件等。該方法更像是一個對象生命週期的臨終方法，當該方法被系統調用則表明該對象即將「死亡」，可是須要注意的是，咱們主動行爲上去調用該方法並不會致使該對象「死亡」，這是一個被動的方法（其實就是回調方法），不須要咱們調用。

5、JavaSE 經常使用 API

1. Math.round(11.5)等於多少？Math.round(- 11.5) 又等於多少?

Math.round(11.5)的返回值是 12，Math.round(-11.5)的返回值是-11。四捨五入的原理是在參數上加 0.5而後進行取整。

2. switch 是否能做用在 byte 上，是否能做用在 long 上，是否能做用在 String上?

Java5 之前 switch(expr)中，expr 只能是 byte、short、char、int。從 Java 5 開始，Java 中引入了枚舉類型，expr 也能夠是 enum 類型從 Java 7 開始，expr 還能夠是字符串（String），可是長整型（long）在目前全部的版本中都是不能夠的。

3. 數組有沒有 length() 方法？String 有沒有 length() 方法？

數組沒有 length()方法，而是有 length 的屬性。String 有 length()方法。JavaScript 中，得到字符串的長度是經過 length 屬性獲得的，這一點容易和 Java 混淆。

4. String 、StringBuilder 、StringBuffer 的區別？

Java 平臺提供了兩種類型的字符串：String 和 StringBuffer/StringBuilder，它們均可以儲存和操做字符串，區別以下。

1）String 是隻讀字符串，也就意味着 String 引用的字符串內容是不能被改變的。初學者可能會有這樣的誤解：

1. String str = 「abc」；2. str = 「bcd」;

如上，字符串 str 明明是能夠改變的呀！其實否則，str 僅僅是一個引用對象，它指向一個字符串對象「abc」。第二行代碼的含義是讓 str 從新指向了一個新的字符串「bcd」對象，而「abc」對象並無任何改變，只不過該對象已經成爲一個不可及對象罷了。

2）StringBuffer/StringBuilder 表示的字符串對象能夠直接進行修改。　　　　　　　　經常使用StringBuilder

3）StringBuilder 是 Java5 中引入的，它和 StringBuffer 的方法徹底相同，區別在於它是在單線程環境下使用的，由於它的全部方法都沒有被 synchronized 修飾，所以它的效率理論上也比 StringBuffer 要高。

6、Java 的數據類型

1. Java 的基本數據類型都有哪些各佔幾個字節

以下表所示：

2. String 是基本數據類型嗎？

String 是引用類型，底層用 char 數組實現的。

3. short s1 = 1; s1 = s1 + 1; 有錯嗎?short s1 = 1; s1 += 1 有錯嗎？

前者不正確，後者正確。對於 short s1 = 1; s1 = s1 + 1;因爲 1 是 int 類型，所以 s1+1 運算結果也是 int 型，須要強制轉換類型才能賦值給 short 型。而 short s1 = 1; s1 += 1;能夠正確編譯，由於 s1+= 1;至關於 s1 =
(short)(s1 + 1);其中有隱含的強制類型轉換。

4. int 和和 Integer 有什麼區別？

Java 是一個近乎純潔的面向對象編程語言，可是爲了編程的方便仍是引入了基本數據類型，爲了可以將這些基本數據類型當成對象操做，Java 爲每個基本數據類型都引入了對應的包裝類型（wrapper class），int 的包裝類就是Integer，從 Java 5 開始引入了自動裝箱/拆箱機制，使得兩者能夠相互轉換。

　　Java 爲每一個原始類型提供了包裝類型：

　　- 原始類型: boolean，char，byte，short，int，long，float，double

　　- 包裝類型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

5. 下面 Integer 類型的數值比較輸出的結果爲？

若是不明就裏很容易認爲兩個輸出要麼都是 true 要麼都是 false。首先須要注意的是 f一、f二、f三、f4 四個變量都是 Integer 對象引用，因此下面的==運算比較的不是值而是引用。裝箱的本質是什麼呢？當咱們給一個 Integer 對象賦一個 int 值的時候，會調用 Integer 類的靜態方法 valueOf，若是看看 valueOf 的源代碼就知道發生了什麼。

　　源碼：

簡單的說，若是整型字面量的值在-128 到 127 之間，那麼不會 new 新的 Integer 對象，而是直接引用常量池中的 Integer 對象，因此上面的面試題中 f1==f2 的結果是 true，而 f3==f4 的結果是 false。

6. String 類經常使用方法

7. String、StringBuffer、StringBuilder 的區別？

（1）可變不可變

String：字符串常量，在修改時不會改變自身；若修改，等於從新生成新的字符串對象。

StringBuffer：在修改時會改變對象自身，每次操做都是對 StringBuffer 對象自己進行修改，不是生成新的對象；使用場景：對字符串常常改變狀況下，主要方法：append（），insert（）等。

（2）線程是否安全

String：對象定義後不可變，線程安全。

StringBuffer：是線程安全的（對調用方法加入同步鎖），執行效率較慢，適用於多線程下操做字符串緩衝區大量數據。

StringBuilder：是線程不安全的，適用於單線程下操做字符串緩衝區大量數據。

（3）共同點

StringBuilder 與 StringBuffer 有公共父類 AbstractStringBuilder(抽象類)。

StringBuilder、StringBuffer 的方法都會調用 AbstractStringBuilder 中的公共方法，如 super.append(...)。只是 StringBuffer 會在方法上加 synchronized 關鍵字，進行同步。最後，若是程序不是多線程的，那麼使用StringBuilder 效率高於 StringBuffer。

8. 數據類型之間的轉換

（1）字符串如何轉基本數據類型？調用基本數據類型對應的包裝類中的方法 parseXXX(String)或 valueOf(String)便可返回相應基本類型。

（2）基本數據類型如何轉字符串？一種方法是將基本數據類型與空字符串（「」）鏈接（+）便可得到其所對應的字符串；另外一種方法是調用 String
　　類中的 valueOf()方法返回相應字符串。

7、Java 的 IO

1. Java 中有幾種類型的流

按照流的方向：輸入流（inputStream）和輸出流（outputStream）。

按照實現功能分：節點流（能夠從或向一個特定的地方（節點）讀寫數據。如 FileReader）和處理流（是對一個已存在的流的鏈接和封裝，經過所封裝的流的功能調用實現數據讀寫。如 BufferedReader。處理流的構造方法老是要帶一個其餘的

流對象作參數。一個流對象通過其餘流的屢次包裝，稱爲流的連接。）

按照處理數據的單位：字節流和字符流。字節流繼承於 InputStream 和 OutputStream，字符流繼承於InputStreamReader 和 OutputStreamWriter。

2. 字節流如何轉爲字符流

字節輸入流轉字符輸入流經過 InputStreamReader 實現，該類的構造函數能夠傳入 InputStream 對象。字節輸出流轉字符輸出流經過 OutputStreamWriter 實現，該類的構造函數能夠傳入 OutputStream 對象。

3. 如何將一個 java 對象序列化到文件裏

4. 字節流和字符流的區別

字節流讀取的時候，讀到一個字節就返回一個字節；字符流使用了字節流讀到一個或多個字節（中文對應的字節數是兩個，在 UTF-8 碼錶中是 3 個字節）時。先去查指定的編碼表，將查到的字符返回。字節流能夠處理全部類型數據，如：圖片，MP3，AVI 視頻文件，而字符流只能處理字符數據。只要是處理純文本數據，就要優先考慮使用字符流，除此以外都用字節流。字節流主要是操做 byte 類型數據，以 byte 數組爲準，主要操做類就是 OutputStream、InputStream

字符流處理的單元爲 2 個字節的 Unicode 字符，分別操做字符、字符數組或字符串，而字節流處理單元爲 1 個字節，操做字節和字節數組。因此字符流是由 Java 虛擬機將字節轉化爲 2 個字節的 Unicode 字符爲單位的字符而成的，因此它對多國語言支持性比較好！若是是音頻文件、圖片、歌曲，就用字節流好點，若是是關係到中文（文本）的，用字符流好點。在程序中一個字符等於兩個字節，java 提供了 Reader、Writer 兩個專門操做字符流的類。

5. 什麼是 java 序列化，如何實現 java 序列化？

序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。能夠對流化後的對象進行讀寫操做，也可將流化後的對象傳輸於網絡之間。序列化是爲了解決在對對象流進行讀寫操做時所引起的問題。

序列化的實現：將需要被序列化的類實現 Serializable 接口，該接口沒有需要實現的方法，implements Serializable 只是爲了標註該對象是可被序列化的，而後使用一個輸出流(如：FileOutputStream)來構造一

ObjectOutputStream(對象流)對象，接着，使用 ObjectOutputStream 對象的 writeObject(Object obj)方法就能夠將參數爲 obj 的對象寫出(即保存其狀態)，要恢復的話則用輸入流。

8、Java 的集合

2. 集合的安全性問題

請問 ArrayList、HashSet、HashMap 是線程安全的嗎？

咱們都看過上面那些集合的源碼（若是沒有那就看看吧），每一個方法都沒有加鎖，顯然都是線程不安全的。話又說過來若是他們安全了也就沒第二問了。在集合中 Vector 和 HashTable 卻是線程安全的。你打開源碼會發現其實就是把各自核心方法添加上了synchronized 關鍵字。

Collections 工具類提供了相關的 API，可讓上面那 3 個不安全的集合變爲安全的。

1. // Collections.synchronizedCollection(c)
2. // Collections.synchronizedList(list)
3. // Collections.synchronizedMap(m)
4. // Collections.synchronizedSet(s)

上面幾個函數都有對應的返回值類型，傳入什麼類型返回什麼類型。打開源碼其實實現原理很是簡單，就是將集合的核心方法添加上了 synchronized 關鍵字。

3. ArrayList 內部用什麼實現的？

ArrayList 內部是用 Object[]實現的。接下來咱們分別分析 ArrayList 的構造、add、remove、clear 方法的實現原理

　　1、構造函數

　　　　1）空參構造

/** * Constructs a new {@code ArrayList} instance with zero initial capacity. */
 public ArrayList() { array = EmptyArray.OBJECT; }

array 是一個 Object[]類型。當咱們 new 一個空參構造時系統調用了 EmptyArray.OBJECT 屬性，EmptyArray 僅僅是一個系統的類庫，該類源碼以下：

public final class EmptyArray { private EmptyArray() {} public static final boolean[] BOOLEAN = new boolean[0]; public static final byte[] BYTE = new byte[0]; public static final char[] CHAR = new char[0]; public static final double[] DOUBLE = new double[0]; public static final int[] INT = new int[0]; public static final Class<?>[] CLASS = new Class[0]; public static final Object[] OBJECT = new Object[0]; public static final String[] STRING = new String[0]; public static final Throwable[] THROWABLE = new Throwable[0]; public static final StackTraceElement[] STACK_TRACE_ELEMENT = new StackTraceElement[0]; }

也就是說當咱們 new 一個空參 ArrayList 的時候，系統內部使用了一個 new Object[0]數組。

　　　　2）帶參構造 1

/** * Constructs a new instance of {@code ArrayList} with the specified * initial capacity. * * @param capacity * the initial capacity of this {@code ArrayList}. */
 public ArrayList(int capacity) { if (capacity < 0) { throw new IllegalArgumentException("capacity < 0: " + capacity);

　　}
　　　　array = (capacity == 0 ? EmptyArray.OBJECT : new Object[capacity]);
}

該構造函數傳入一個 int 值，該值做爲數組的長度值。若是該值小於 0，則拋出一個運行時異常。若是等於 0，則使用一個空數組，若是大於 0，則建立一個長度爲該值的新數組。

　　　　3）帶參構造 2

/** * Constructs a new instance of {@code ArrayList} containing the elements of * the specified collection. * * @param collection * the collection of elements to add. */
 public ArrayList(Collection<? extends E> collection) { if (collection == null) { throw new NullPointerException("collection == null"); } Object[] a = collection.toArray(); if (a.getClass() != Object[].class) { Object[] newArray = new Object[a.length]; System.arraycopy(a, 0, newArray, 0, a.length); a = newArray; } array = a; size = a.length; }

若是調用構造函數的時候傳入了一個 Collection 的子類，那麼先判斷該集合是否爲 null，爲 null 則拋出空指針異常。若是不是則將該集合轉換爲數組 a，而後將該數組賦值爲成員變量 array，將該數組的長度做爲成員變量 size。這裏面它先判斷 a.getClass 是否等於 Object[].class，其實通常都是相等的，我也暫時沒想明白爲何多加了這個判斷，toArray 方法是 Collection 接口定義的，所以其全部的子類都有這樣的方法，list 集合的 toArray 和 Set 集合的 toArray返回的都是 Object[]數組。

　　2、add 方法

 /** * Adds the specified object at the end of this {@code ArrayList}. * * @param object * the object to add. * @return always true */ @Override public boolean add(E object) { Object[] a = array; int s = size; if (s == a.length) { Object[] newArray = new Object[s + (s < (MIN_CAPACITY_INCREMENT / 2) ? MIN_CAPACITY_INCREMENT : s >> 1)]; System.arraycopy(a, 0, newArray, 0, s); array = a = newArray; } a[s] = object; size = s + 1; modCount++; return true; }

一、首先將成員變量 array 賦值給局部變量 a，將成員變量 size 賦值給局部變量 s。
二、判斷集合的長度 s 是否等於數組的長度（若是集合的長度已經等於數組的長度了，說明數組已經滿了，該從新分配新數組了），從新分配數組的時候須要計算新分配內存的空間大小，
　 若是當前的長度小於MIN_CAPACITY_INCREMENT/2（這個常量值是 12，除以 2 就是 6，也就是若是當前集合長度小於 6）則分配 12 個長度，若是集合長度大於 6 則分配當前長度 s 的一半長度。
　 這裏面用到了三元運算符和位運算，s >> 1，意思就是將s 往右移 1 位，至關於 s=s/2，只不過位運算是效率最高的運算.
三、將新添加的 object 對象做爲數組的 a[s]個元素。
四、修改集合長度 size 爲 s+1
五、modCotun++,該變量是父類中聲明的，用於記錄集合修改的次數，記錄集合修改的次數是爲了防止在用迭代器迭代集合時避免併發修改異常，或者說用於判斷是否出現併發修改異常的。
六、return true，這個返回值意義不大，由於一直返回 true，除非報了一個運行時異常。

　　3、remove 方法

 /** * Removes the object at the specified location from this list. * * @param index * the index of the object to remove. * @return the removed object. * @throws IndexOutOfBoundsException * when {@code location < 0 || location >= size()} */ @Override public E remove(int index) { Object[] a = array; int s = size; if (index >= s) { throwIndexOutOfBoundsException(index, s); } @SuppressWarnings("unchecked") E result = (E) a[index]; System.arraycopy(a, index + 1, a, index, --s - index); a[s] = null; // Prevent memory leak
 size = s; modCount++; return result; }

一、先將成員變量 array 和 size 賦值給局部變量 a 和 s。
二、判斷形參 index 是否大於等於集合的長度，若是成了則拋出運行時異常
三、獲取數組中腳標爲 index 的對象 result，該對象做爲方法的返回值
四、調用 System 的 arraycopy 函數，拷貝原理以下圖所示。

五、接下來就是很重要的一個工做，由於刪除了一個元素，並且集合總體向前移動了一位，所以須要將集合最後一個元素設置爲 null，不然就可能內存泄露。

六、從新給成員變量 array 和 size 賦值

七、記錄修改次數

八、返回刪除的元素（讓用戶再看最後一眼）

　　4、clear 方法

 /** * Removes all elements from this {@code ArrayList}, leaving it empty. * * @see #isEmpty * @see #size */ @Override public void clear() { if (size != 0) { Arrays.fill(array, 0, size, null); size = 0; modCount++; } }

若是集合長度不等於 0，則將全部數組的值都設置爲 null，而後將成員變量 size 設置爲 0 便可，最後讓修改記錄加 1。

5. List 的三個子類的特色

ArrayList 底層結構是數組,底層查詢快,增刪慢。

LinkedList 底層結構是鏈表型的,增刪快,查詢慢。

voctor 底層結構是數組線程安全的,增刪慢,查詢慢。

6. List 和 Map、Set 的區別

6.1 結構特色

List 和 Set 是存儲單列數據的集合，Map 是存儲鍵和值這樣的雙列數據的集合；List 中存儲的數據是有順序，而且容許重複；Map 中存儲的數據是沒有順序的，其鍵是不能重複的，它的值是能夠有重複的，Set 中存儲的數據是無序的，且不容許有重複，但元素在集合中的位置由元素的 hashcode 決定，位置是固定的（Set 集合根據 hashcode 來進行數據的存儲，因此位置是固定的，可是位置不是用戶能夠控制的，因此對於用戶來講 set 中的元素仍是無序的）；

6.2 實現類

List 接口有三個實現類（LinkedList：基於鏈表實現，鏈表內存是散亂的，每個元素存儲自己內存地址的同時還存儲下一個元素的地址。鏈表增刪快，查找慢；ArrayList：基於數組實現，非線程安全的，效率高，便於索引，但不便於插入刪除；Vector：基於數組實現，線程安全的，效率低）。

Map 接口有三個實現類（HashMap：基於 hash 表的 Map 接口實現，非線程安全，高效，支持 null 值和 null鍵；HashTable：線程安全，低效，不支持 null 值和 null 鍵；LinkedHashMap：是 HashMap 的一個子類，保存了記錄的插入順序；SortMap 接口：TreeMap，可以把它保存的記錄根據鍵排序，默認是鍵值的升序排序）。Set 接口有兩個實現類（HashSet：底層是由 HashMap 實現，不容許集合中有重複的值，使用該方式時須要重寫 equals()和 hashCode()方法；LinkedHashSet：繼承與 HashSet，同時又基於 LinkedHashMap 來進行實現，底層使用的是 LinkedHashMp）。

6.3 區別

List 集合中對象按照索引位置排序，能夠有重複對象，容許按照對象在集合中的索引位置檢索對象，例如經過list.get(i)方法來獲取集合中的元素；Map 中的每個元素包含一個鍵和一個值，成對出現，鍵對象不能夠重複，值對象能夠重複；Set 集合中的對象不按照特定的方式排序，而且沒有重複對象，但它的實現類能對集合中的對象按照特定的方式排序，例如 TreeSet 類，能夠按照默認順序，也能夠經過實現 Java.util.Comparator<Type>接口來自定義排序方式。

7. HashMap 和 HashTable 有什麼區別?

HashMap 是線程不安全的,HashMap 是一個接口,是 Map 的一個子接口,是將鍵映射到值得對象,不容許鍵值重複,容許空鍵和空值;因爲非線程安全,HashMap 的效率要較 HashTable 的效率高一些

HashTable 是線程安全的一個集合,不容許 null 值做爲一個 key 值或者 Value 值;

HashTable 是 sychronize,多個線程訪問時不須要本身爲它的方法實現同步,而 HashMap 在被多個線程訪問的時候須要本身爲它的方法實現同步;

8. 數組和鏈表的區別

數組是將元素在內存中連續存儲的；它的優勢：由於數據是連續存儲的，內存地址連續，因此在查找數據的時候效率比較高；它的缺點：在存儲以前，咱們須要申請一塊連續的內存空間，而且在編譯的時候就必須肯定好它的空間的大小。在運行的時候空間的大小是沒法隨着你的須要進行增長和減小而改變的，當數據兩比較大的時候，有可能會出現越界的狀況，數據比較小的時候，又有可能會浪費掉內存空間。在改變數據個數時，增長、插入、刪除數據效率比較低

鏈表是動態申請內存空間，不須要像數組須要提早申請好內存的大小，鏈表只需在用的時候申請就能夠，根據須要來動態申請或者刪除內存空間，對於數據增長和刪除以及插入比數組靈活。還有就是鏈表中數據在內存中能夠在任意的位置，經過應用來關聯數據（就是經過存在元素的指針來聯繫）

鏈表和數組使用場景

數組應用場景：數據比較少；常常作的運算是按序號訪問數據元素；數組更容易實現，任何高級語言都支持；構建的線性表較穩定。

鏈表應用場景：對線性表的長度或者規模難以估計；頻繁作插入刪除操做；構建動態性比較強的線性表。

9. Java 中 ArrayList 和 Linkedlist 區別？

ArrayList 和 Vector 使用了數組的實現，能夠認爲 ArrayList 或者 Vector 封裝了對內部數組的操做，好比向數組中添加，刪除，插入新的元素或者數據的擴展和重定向。

LinkedList 使用了循環雙向鏈表數據結構。與基於數組的 ArrayList 相比，這是兩種大相徑庭的實現技術，這也決定了它們將適用於徹底不一樣的工做場景。

LinkedList 鏈表由一系列表項鍊接而成。一個表項老是包含 3 個部分：元素內容，前驅表和後驅表，如圖所示：

在下圖展現了一個包含 3 個元素的 LinkedList 的各個表項間的鏈接關係。在 JDK 的實現中，不管 LikedList 是否爲空，鏈表內部都有一個 header 表項，它既表示鏈表的開始，也表示鏈表的結尾。表項 header 的後驅表項即是鏈表中第一個元素，表項 header 的前驅表項即是鏈表中最後一個元素。

10. List a=new ArrayList()和 ArrayList a =new ArrayList()的區別？

List list = new ArrayList();這句建立了一個 ArrayList 的對象後把上溯到了 List。此時它是一個 List 對象了，有些ArrayList 有可是 List 沒有的屬性和方法，它就不能再用了。而 ArrayList list=new ArrayList();建立一對象則保留了ArrayList 的全部屬性。因此須要用到 ArrayList 獨有的方法的時候不能用前者。實例代碼以下：

1．List list = new ArrayList();
2．ArrayList arrayList = new ArrayList();
3．list.trimToSize(); //錯誤，沒有該方法。
4．arrayList.trimToSize(); //ArrayList 裏有該方法。

ArrayList所說沒有用的值並非null，而是ArrayList每次增加會預申請多一點空間，1.5倍+1，而不是兩倍
這樣就會出現當size() = 1000的時候，ArrayList已經申請了1200空間的狀況
trimToSize 的做用只是去掉預留元素位置，就是刪除多餘的200，改成只申請1000,內存緊張的時候會用到

11. Collection 和 Map 的集成體系

　　　　　　　　Map：

12. Map 中的 key 和 value 能夠爲 null 麼？

HashMap 對象的 key、value 值都可爲 null。HahTable 對象的 key、value 值均不可爲 null。

9、Java 的多線程和併發庫

（一）多線程基礎知識--傳統線程機制的回顧

1.在 Thread 子類覆蓋的 run 方法中編寫運行代碼

　　方式一

new Thread(){
　　@Override
　　public void run(){
　　　　while(true){
　　　　try {
　　　　　　Thread.sleep(2000);
　　　　} catch (InterruptedException e) {
　　　　　　e.printStackTrace();
　　}
}
}
}.start();

2.在傳遞給 Thread 對象的 Runnable 對象的 run 方法中編寫代碼

new Thread(new Runnable(){
    public void run(){
        while(true)
            {try {Thread.sleep(2000);
            } catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }
    }
}).start();

3.總結

查看 Thread 類的 run()方法的源代碼，能夠看到其實這兩種方式都是在調用 Thread 對象的 run 方法，若是 Thread
類的 run 方法沒有被覆蓋，而且爲該 Thread 對象設置了一個 Runnable 對象，該 run 方法會調用 Runnable 對象的
run 方法

 /** 
    * If this thread was constructed using a separa 
    * <code>Runnable</code> run object, then that 
    * <code>Runnable</code> object's <code>run</cod 
    * otherwise, this method does nothing and retur 
    * <p> 
    * Subclasses of <code>Thread</code> should over 
    * 
    * @see #start() 
    * @see #stop() 
    * @see #Thread(ThreadGroup, Runnable, String 
    */ 
@Override 
public void run() {
     if (target != null) {
         target.run(); 
}

1. 多線程的建立方式

（1）、繼承 Thread 類：但 Thread 本質上也是實現了 Runnable 接口的一個實例，它表明一個線程的實例，而且，啓動線程的惟一方法就是經過 Thread 類的 start()實例方法。start()方法是一個 native 方法，它將啓動一個新線程，並執行 run()方法。這種方式實現多線程很簡單，經過本身的類直接 extend Thread，並複寫 run()方法，就能夠啓動新線程並執行本身定義的 run()方法。例如：繼承 Thread 類實現多線程，並在合適的地方啓動線程

1．public class MyThread extends Thread { 
2． public void run() { 
3． System.out.println("MyThread.run()"); 
4． }
5．}
6．MyThread myThread1 = new MyThread(); 
7．MyThread myThread2 = new MyThread(); 
8．myThread1.start(); 
9．myThread2.start();

（2）、實現 Runnable 接口的方式實現多線程，而且實例化 Thread，傳入本身的 Thread 實例，調用 run( )方法

1．public class MyThread implements Runnable { 
2． public void run() { 
3． System.out.println("MyThread.run()"); 
4． } 
5．}
6．MyThread myThread = new MyThread(); 
7．Thread thread = new Thread(myThread); 
8．thread.start();

（3）、使用 ExecutorService、Callable、Future 實現有返回結果的多線程：ExecutorService、Callable、Future這個對象實際上都是屬於 Executor 框架中的功能類。想要詳細了解 Executor 框架的可以訪問http://www.javaeye.com/topic/366591 ，這裏面對該框架作了很詳細的解釋。返回結果的線程是在 JDK1.5 中引入的新特徵，確實很實用，有了這種特徵我就不須要再爲了獲得返回值而大費周折了，並且即使實現了也可能漏洞百出。可返回值的任務必須實現 Callable 接口，相似的，無返回值的任務必須 Runnable 接口。執行 Callable 任務後，能夠獲取一個 Future 的對象，在該對象上調用 get 就能夠獲取到 Callable 任務返回的 Object 了，再結合線程池接口ExecutorService 就能夠實現傳說中有返回結果的多線程了。下面提供了一個完整的有返回結果的多線程測試例子，在JDK1.5 下驗證過沒問題能夠直接使用。代碼以下：

1．import java.util.concurrent.*; 
2．import java.util.Date; 
3．import java.util.List; 
4．import java.util.ArrayList; 
5． 
6．/** 
7．* 有返回值的線程
8．*/
9．@SuppressWarnings("unchecked") 
10．public class Test { 
11．public static void main(String[] args) throws ExecutionException, 12． InterruptedException { 
13． System.out.println("----程序開始運行----"); 
14． Date date1 = new Date(); 
15． 
16． int taskSize = 5; 
17． // 建立一個線程池 
18． ExecutorService pool = Executors.newFixedThreadPool(taskSize); 
19． // 建立多個有返回值的任務 
20． List<Future> list = new ArrayList<Future>(); 
21． for (int i = 0; i < taskSize; i++) { 
22． Callable c = new MyCallable(i + " "); 
23． // 執行任務並獲取 Future 對象 
24． Future f = pool.submit(c); 
25． // System.out.println(">>>" + f.get().toString()); 
26． list.add(f); 
27． } 
28． // 關閉線程池 
29． pool.shutdown(); 
30． 
31． // 獲取全部併發任務的運行結果 
32． for (Future f : list) { 
33． // 從 Future 對象上獲取任務的返回值，並輸出到控制檯 
34． System.out.println(">>>" + f.get().toString()); 
35． } 
36． 
37． Date date2 = new Date(); 
38． System.out.println("----程序結束運行----，程序運行時間【" 
39． + (date2.getTime() - date1.getTime()) + "毫秒】"); 
40．} 
41．} 
42． 
43．class MyCallable implements Callable<Object> { 
44．private String taskNum; 
45． 
46．MyCallable(String taskNum) { 
47． this.taskNum = taskNum; 
48．} 
49． 
50．public Object call() throws Exception { 
51． System.out.println(">>>" + taskNum + "任務啓動");
52． Date dateTmp1 = new Date(); 
53． Thread.sleep(1000); 
54． Date dateTmp2 = new Date(); 
55． long time = dateTmp2.getTime() - dateTmp1.getTime(); 
56． System.out.println(">>>" + taskNum + "任務終止"); 
57． return taskNum + "任務返回運行結果,當前任務時間【" + time + "毫秒】"; 
58．} 
59．}

2. 在 java 中 wait 和 sleep 方法的不一樣？

最大的不一樣是在等待時 wait 會釋放鎖，而 sleep 一直持有鎖。wait 一般被用於線程間交互，sleep 一般被用於暫停執行。

3. synchronized 和 volatile 關鍵字的做用

一旦一個共享變量（類的成員變量、類的靜態成員變量）被 volatile 修飾以後，那麼就具有了兩層語義：

1）保證了不一樣線程對這個變量進行操做時的可見性，即一個線程修改了某個變量的值，這新值對其餘線程來講是當即可見的

2）禁止進行指令重排序。

volatile 本質是在告訴 jvm 當前變量在寄存器（工做內存）中的值是不肯定的，須要從主存中讀取；synchronized 則是鎖定當前變量，只有當前線程能夠訪問該變量，其餘線程被阻塞住。

1.volatile 僅能使用在變量級別；synchronized 則可使用在變量、方法、和類級別的

2.volatile 僅能實現變量的修改可見性，並不能保證原子性；synchronized 則能夠保證變量的修改可見性和原子性

3.volatile 不會形成線程的阻塞；synchronized 可能會形成線程的阻塞。

4.volatile 標記的變量不會被編譯器優化；synchronized 標記的變量能夠被編譯器優化

4.什麼是線程池，如何使用？

線程池就是事先將多個線程對象放到一個容器中，當使用的時候就不用 new 線程而是直接去池中拿線程便可，節省了開闢子線程的時間，提升的代碼執行效率。

在 JDK 的 java.util.concurrent.Executors 中提供了生成多種線程池的靜態方法。

1. ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
2. ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4);
3. ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(4);
4. ExecutorService newSingleThreadExecutor =Executors.newSingleThreadExecutor();

而後調用他們的 execute 方法便可。