Java 面試随着時間的改變而改變。在過去的日子裡，當你知道 String 和 StringBuilder 的差別（String 類型和 StringBuffer 類型的主要性能差別其實在于 String 是不可變的對象。是以在每次對 String 類型進行改變的時候其實都等同于生成了一個新的 String 對象，然後将指針指向新的 String 對象，是以經常改變内容的字元串最好不要用 String ，因為每次生成對象都會對系統性能産生影響，特别當記憶體中無引用對象多了以後，JVM 的 GC 就會開始工作，影響性能，可以考慮使用可變字元序列StringBuilder）就能讓你直接進入第二輪面試，但是現在問題變得越來越進階，面試官問的問題也更深入。 在我初入職場的時候，類似于 Vector 與 Array 的差別、HashMap 與 Hashtable 的差別是最流行的問題，隻需要記住它們，就能在面試中獲得更好的機會，但這種情形已經不複存在。如今，你将會被問到許多 Java 程式員都沒有看過的領域，如 NIO，設計模式，成熟的單元測試，或者那些很難掌握的知識，如并發、算法、資料結構及編碼。
由于我喜歡研究面試題，是以我已經收集了許多的面試問題，包括許多許多不同的主題。我已經為這衆多的問題準備一段時間了，現在我将它們分享給你們。這裡面不但包含經典的面試問題，如線程、集合、equals 和 hashcode、socket，而且還包含了 NIO、數組、字元串、Java 8 等主題。
該清單包含了入門級 Java 程式員和多年經驗的進階開發者的問題。無論你是 1、2、3、4、5、6、7、8、9 還是 10 年經驗的開發者，你都能在其中找到一些有趣的問題。這裡包含了一些超級容易回答的問題，同時包含經驗豐富的 Java 程式員也會棘手的問題。
當然你們也是非常幸運的，當今有許多好的書來幫助你準備 Java 面試，其中有一本我覺得特别有用和有趣的是 Markham 的 Java 程式面試揭秘（Java Programming Interview Exposed）。 這本書會告訴你一些 Java 和 JEE 面試中最重要的主題，即使你不是準備 Java 面試，也值得一讀。
該問題清單特别長，我們有各個地方的問題，是以，答案必須要短小、簡潔、幹脆，不拖泥帶水。是以，除了這一個段落，你隻會聽到問題與答案，再無其他内容，沒有回報，也沒有評價。為此，我已經寫好了一些博文，在這些文章中你可以找到我對某些問題的觀點，如我為什麼喜歡這個問題，這個問題的挑戰是什麼？期望從面試者那擷取到什麼樣的答案？
這個清單有一點不同，我鼓勵你采用類似的方式去分享問題和答案，這樣容易溫習。我希望這個清單對面試官和候選人都有很好的用處，面試官可以對這些問題上做一些改變以擷取新奇和令人驚奇的元素，這對一次好的面試來說非常重要。而候選者，可以擴充和測試 Java 程式語言和平台關鍵領域的知識。2015 年，會更多的關注并發概念，JVM 内部，32 位 JVM 和 64 JVM的差別，單元測試及整潔的代碼。我确信，如果你讀過這個龐大的 Java 面試問題清單，無論是電話面試還是面對面的面試，你都能有很好的表現。
Java 面試中的重要話題
除了你看到的驚人的問題數量，我也盡量保證品質。我不止一次分享各個重要主題中的問題，也確定包含所謂的進階話題，這些話題很多程式員不喜歡準備或者直接放棄，因為他們的工作不會涉及到這些。Java NIO 和 JVM 底層就是最好的例子。你也可以将設計模式劃分到這一類中，但是越來越多有經驗的程式員了解 GOF 設計模式并應用這些模式。我也盡量在這個清單中包含 2015 年最新的面試問題，這些問題可能是來年關注的核心。為了給你一個大緻的了解,下面列出這份 Java 面試問題清單包含的主題：
- 多線程，并發及線程基礎
- 資料類型轉換的基本原則
- 垃圾回收（GC）
- Java 集合架構
- 數組
- 字元串
- GOF 設計模式
- SOLID （單一功能、開閉原則、裡氏替換、接口隔離以及依賴反轉）設計原則
- 抽象類與接口
- Java 基礎，如 equals 和 hashcode
- 泛型與枚舉
- Java IO 與 NIO
- 常用網絡協定
- Java 中的資料結構和算法
- 正規表達式
- JVM 底層
- Java 最佳實踐
- JDBC
- Date, Time 與 Calendar
- Java 處理 XML
- JUnit
- 程式設計
120 大 Java 面試題及答案
現在是時候給你展示我近 5 年從各種面試中收集來的 120 個問題了。我确定你在自己的面試中見過很多這些問題，很多問題你也能正确回答。
多線程、并發及線程的基礎問題
1）Java 中能建立 volatile 數組嗎？
能，Java 中可以建立 volatile 類型數組，不過隻是一個指向數組的引用，而不是整個數組。我的意思是，如果改變引用指向的數組，将會受到 volatile 的保護，但是如果多個線程同時改變數組的元素，volatile 标示符就不能起到之前的保護作用了。
2）volatile 能使得一個非原子操作變成原子操作嗎？
一個典型的例子是在類中有一個 long 類型的成員變量。如果你知道該成員變量會被多個線程通路，如計數器、價格等，你最好是将其設定為 volatile。為什麼？因為 Java 中讀取 long 類型變量不是原子的，需要分成兩步，如果一個線程正在修改該 long 變量的值，另一個線程可能隻能看到該值的一半（前 32 位）。但是對一個 volatile 型的 long 或 double 變量的讀寫是原子。
3）volatile 修飾符的有過什麼實踐？
一種實踐是用 volatile 修飾 long 和 double 變量，使其能按原子類型來讀寫。double 和 long 都是64位寬，是以對這兩種類型的讀是分為兩部分的，第一次讀取第一個 32 位，然後再讀剩下的 32 位，這個過程不是原子的，但 Java 中 volatile 型的 long 或 double 變量的讀寫是原子的。volatile 修複符的另一個作用是提供記憶體屏障（memory barrier），例如在分布式架構中的應用。簡單的說，就是當你寫一個 volatile 變量之前，Java 記憶體模型會插入一個寫屏障（write barrier），讀一個 volatile 變量之前，會插入一個讀屏障（read barrier）。意思就是說，在你寫一個 volatile 域時，能保證任何線程都能看到你寫的值，同時，在寫之前，也能保證任何數值的更新對所有線程是可見的，因為記憶體屏障會将其他所有寫的值更新到緩存。
4）volatile 類型變量提供什麼保證？
volatile 變量提供順序和可見性保證，例如，JVM 或者 JIT為了獲得更好的性能會對語句重排序，但是 volatile 類型變量即使在沒有同步塊的情況下指派也不會與其他語句重排序。 volatile 提供 happens-before 的保證，確定一個線程的修改能對其他線程是可見的。某些情況下，volatile 還能提供原子性，如讀 64 位資料類型，像 long 和 double 都不是原子的，但 volatile 類型的 double 和 long 就是原子的。
5) 10 個線程和 2 個線程的同步代碼，哪個更容易寫？
從寫代碼的角度來說，兩者的複雜度是相同的，因為同步代碼與線程數量是互相獨立的。但是同步政策的選擇依賴于線程的數量，因為越多的線程意味着更大的競争，是以你需要利用同步技術，如鎖分離，這要求更複雜的代碼和專業知識。
6）你是如何調用 wait（）方法的？使用 if 塊還是循環？為什麼？
wait() 方法應該在循環調用，因為當線程擷取到 CPU 開始執行的時候，其他條件可能還沒有滿足，是以在處理前，循環檢測條件是否滿足會更好。下面是一段标準的使用 wait 和 notify 方法的代碼：
// The standard idiom for using the wait method
synchronized (obj) {
while (condition does not hold)
obj.wait(); // (Releases lock, and reacquires on wakeup)
... // Perform action appropriate to condition
}
參見 Effective Java 第 69 條，擷取更多關于為什麼應該在循環中來調用 wait 方法的内容。
7）什麼是多線程環境下的僞共享（false sharing）？
僞共享是多線程系統（每個處理器有自己的局部緩存）中一個衆所周知的性能問題。僞共享發生在不同處理器的上的線程對變量的修改依賴于相同的緩存行，如下圖所示：
僞共享問題很難被發現，因為線程可能通路完全不同的全局變量，記憶體中卻碰巧在很相近的位置上。如其他諸多的并發問題，避免僞共享的最基本方式是仔細審查代碼，根據緩存行來調整你的資料結構。
有經驗程式員的 Java 面試題
8）什麼是 Busy spin？我們為什麼要使用它？
Busy spin 是一種在不釋放 CPU 的基礎上等待事件的技術。它經常用于避免丢失 CPU 緩存中的資料（如果線程先暫停，之後在其他CPU上運作就會丢失）。是以，如果你的工作要求低延遲，并且你的線程目前沒有任何順序，這樣你就可以通過循環檢測隊列中的新消息來代替調用 sleep() 或 wait() 方法。它唯一的好處就是你隻需等待很短的時間，如幾微秒或幾納秒。LMAX 分布式架構是一個高性能線程間通信的庫，該庫有一個 BusySpinWaitStrategy 類就是基于這個概念實作的，使用 busy spin 循環 EventProcessors 等待屏障。
9）Java 中怎麼擷取一份線程 dump 檔案？
在 Linux 下，你可以通過指令 kill -3 PID （Java 程序的程序 ID）來擷取 Java 應用的 dump 檔案。在 Windows 下，你可以按下 Ctrl + Break 來擷取。這樣 JVM 就會将線程的 dump 檔案列印到标準輸出或錯誤檔案中，它可能列印在控制台或者日志檔案中，具體位置依賴應用的配置。如果你使用Tomcat。
10）Swing 是線程安全的？
不是，Swing 不是線程安全的。你不能通過任何線程來更新 Swing 元件，如 JTable、JList 或 JPanel，事實上，它們隻能通過 GUI 或 AWT 線程來更新。這就是為什麼 Swing 提供 invokeAndWait() 和 invokeLater() 方法來擷取其他線程的 GUI 更新請求。這些方法将更新請求放入 AWT 的線程隊列中，可以一直等待，也可以通過異步更新直接傳回結果。你也可以在參考答案中檢視和學習到更詳細的内容。
11）什麼是線程局部變量？
當使用ThreadLocal維護變量時,ThreadLocal為每個使用該變量的線程提供獨立的變量副本,每個線程都可以獨立地改變自己的副本,而不會影響其它線程所對應的副本,是線程隔離的。線程隔離的秘密在于ThreadLocalMap類(ThreadLocal的靜态内部類)
線程局部變量是局限于線程内部的變量，屬于線程自身所有，不在多個線程間共享。Java 提供 ThreadLocal 類來支援線程局部變量，是一種實作線程安全的方式。但是在管理環境下（如 web 伺服器）使用線程局部變量的時候要特别小心，在這種情況下，工作線程的生命周期比任何應用變量的生命周期都要長。任何線程局部變量一旦在工作完成後沒有釋放，Java 應用就存在記憶體洩露的風險。
ThreadLocal的方法：void set(T value)、T get()以及T initialValue()。
ThreadLocal是如何為每個線程建立變量的副本的：
首先，在每個線程Thread内部有一個ThreadLocal.ThreadLocalMap類型的成員變量threadLocals，這個threadLocals就是用來存儲實際的變量副本的，鍵值為目前ThreadLocal變量，value為變量副本（即T類型的變量）。初始時，在Thread裡面，threadLocals為空，當通過ThreadLocal變量調用get()方法或者set()方法，就會對Thread類中的threadLocals進行初始化，并且以目前ThreadLocal變量為鍵值，以ThreadLocal要儲存的副本變量為value，存到threadLocals。然後在目前線程裡面，如果要使用副本變量，就可以通過get方法在threadLocals裡面查找。
總結：
a、實際的通過ThreadLocal建立的副本是存儲在每個線程自己的threadLocals中的
b、為何threadLocals的類型ThreadLocalMap的鍵值為ThreadLocal對象，因為每個線程中可有多個threadLocal變量，就像上面代碼中的longLocal和stringLocal；
c、在進行get之前，必須先set，否則會報空指針異常；如果想在get之前不需要調用set就能正常通路的話，必須重寫initialValue()方法
12）用 wait-notify 寫一段代碼來解決生産者-消費者問題？
請參考答案中的示例代碼。隻要記住在同步塊中調用 wait() 和 notify()方法，如果阻塞，通過循環來測試等待條件。
13) 用 Java 寫一個線程安全的單例模式（Singleton）？
請參考答案中的示例代碼，這裡面一步一步教你建立一個線程安全的 Java 單例類。當我們說線程安全時，意思是即使初始化是在多線程環境中，仍然能保證單個執行個體。Java 中，使用枚舉作為單例類是最簡單的方式來建立線程安全單例模式的方式。
14）Java 中 sleep 方法和 wait 方法的差別？
雖然兩者都是用來暫停目前運作的線程，但是 sleep() 實際上隻是短暫停頓，因為它不會釋放鎖，而 wait() 意味着條件等待，這就是為什麼該方法要釋放鎖，因為隻有這樣，其他等待的線程才能在滿足條件時擷取到該鎖。
15）什麼是不可變對象（immutable object）？Java 中怎麼建立一個不可變對象？
不可變對象指對象一旦被建立，狀态就不能再改變。任何修改都會建立一個新的對象，如 String、Integer及其它包裝類。詳情參見答案，一步一步指導你在 Java 中建立一個不可變的類。
16）我們能建立一個包含可變對象的不可變對象嗎？
是的，我們是可以建立一個包含可變對象的不可變對象的，你隻需要謹慎一點，不要共享可變對象的引用就可以了，如果需要變化時，就傳回原對象的一個拷貝。最常見的例子就是對象中包含一個日期對象的引用。
資料類型和 Java 基礎面試問題
17）Java 中應該使用什麼資料類型來代表價格？
如果不是特别關心記憶體和性能的話，使用BigDecimal，否則使用預定義精度的 double 類型。
18）怎麼将 byte 轉換為 String？
可以使用 String 接收 byte[] 參數的構造器來進行轉換，需要注意的點是要使用的正确的編碼，否則會使用平台預設編碼，這個編碼可能跟原來的編碼相同，也可能不同。
19）Java 中怎樣将 bytes 轉換為 long 類型？
String接收bytes的構造器轉成String，再Long.parseLong
20）我們能将 int 強制轉換為 byte 類型的變量嗎？如果該值大于 byte 類型的範圍，将會出現什麼現象？
是的，我們可以做強制轉換，但是 Java 中 int 是 32 位的，而 byte 是 8 位的，是以，如果強制轉化是，int 類型的高 24 位将會被丢棄，byte 類型的範圍是從 -128 到 127。
21）存在兩個類，B 繼承 A，C 繼承 B，我們能将 B 轉換為 C 麼？如 C = (C) B；
可以，向下轉型。但是不建議使用，容易出現類型轉型異常.
22）哪個類包含 clone 方法？是 Cloneable 還是 Object？
java.lang.Cloneable 是一個标示性接口，不包含任何方法，clone 方法在 object 類中定義。并且需要知道 clone() 方法是一個本地方法，這意味着它是由 c 或 c++ 或 其他本地語言實作的。
23）Java 中 ++ 操作符是線程安全的嗎？
不是線程安全的操作。它涉及到多個指令，如讀取變量值，增加，然後存儲回記憶體，這個過程可能會出現多個線程交差。
24）a = a + b 與 a += b 的差別
+= 隐式的将加操作的結果類型強制轉換為持有結果的類型。如果兩這個整型相加，如 byte、short 或者 int，首先會将它們提升到 int 類型，然後在執行加法操作。
byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok
（因為 a+b 操作會将 a、b 提升為 int 類型，是以将 int 類型指派給 byte 就會編譯出錯）
25）我能在不進行強制轉換的情況下将一個 double 值指派給 long 類型的變量嗎？
不行，你不能在沒有強制類型轉換的前提下将一個 double 值指派給 long 類型的變量，因為 double 類型的範圍比 long 類型更廣，是以必須要進行強制轉換。
26）3*0.1 == 0.3 将會傳回什麼？true 還是 false？
false，因為有些浮點數不能完全精确的表示出來。
27）int 和 Integer 哪個會占用更多的記憶體？
Integer 對象會占用更多的記憶體。Integer 是一個對象，需要存儲對象的中繼資料。但是 int 是一個原始類型的資料，是以占用的空間更少。
28）為什麼 Java 中的 String 是不可變的（Immutable）？
Java 中的 String 不可變是因為 Java 的設計者認為字元串使用非常頻繁，将字元串設定為不可變可以允許多個用戶端之間共享相同的字元串。更詳細的内容參見答案。
29）我們能在 Switch 中使用 String 嗎？
從 Java 7 開始，我們可以在 switch case 中使用字元串，但這僅僅是一個文法糖。内部實作在 switch 中使用字元串的 hash code。
30）Java 中的構造器鍊是什麼？
當你從一個構造器中調用另一個構造器，就是Java 中的構造器鍊。這種情況隻在重載了類的構造器的時候才會出現。
JVM 底層 與 GC（Garbage Collection） 的面試問題
31）64 位 JVM 中，int 的長度是多數？
Java 中，int 類型變量的長度是一個固定值，與平台無關，都是 32 位。意思就是說，在 32 位 和 64 位 的Java 虛拟機中，int 類型的長度是相同的。
32）Serial 與 Parallel GC之間的不同之處？
Serial 與 Parallel 在GC執行的時候都會引起 stop-the-world。它們之間主要不同 serial 收集器是預設的複制收集器，執行 GC 的時候隻有一個線程，而 parallel 收集器使用多個 GC 線程來執行。
33）32 位和 64 位的 JVM，int 類型變量的長度是多數？
32 位和 64 位的 JVM 中，int 類型變量的長度是相同的，都是 32 位或者 4 個位元組。
34）Java 中 WeakReference 與 SoftReference的差別？
Java中一共有四種類型的引用。StrongReference、 SoftReference、 WeakReference 以及 PhantomReference。
StrongReference 是 Java 的預設引用實作, 它會盡可能長時間的存活于 JVM 内，當沒有任何對象指向它時将會被GC回收
WeakReference，顧名思義, 是一個弱引用, 當所引用的對象在 JVM 内不再有強引用時, 将被GC回收
雖然 WeakReference 與 SoftReference 都有利于提高 GC 和 記憶體的效率，但是 WeakReference ，一旦失去最後一個強引用，就會被 GC 回收，而 SoftReference 會盡可能長的保留引用直到 JVM 記憶體不足時才會被回收(虛拟機保證), 這一特性使得 SoftReference 非常适合緩存應用
35）WeakHashMap 是怎麼工作的？
WeakHashMap 的工作與正常的 HashMap 類似，但是使用弱引用作為 key，意思就是當 key 對象沒有任何引用時，key/value 将會被回收。
36）JVM 選項 -XX:+UseCompressedOops 有什麼作用？為什麼要使用？
當你将你的應用從 32 位的 JVM 遷移到 64 位的 JVM 時，由于對象的指針從 32 位增加到了 64 位，是以堆記憶體會突然增加，差不多要翻倍。這也會對 CPU 緩存（容量比記憶體小很多）的資料産生不利的影響。因為，遷移到 64 位的 JVM 主要動機在于可以指定最大堆大小，通過壓縮 OOP 可以節省一定的記憶體。通過 -XX:+UseCompressedOops 選項，JVM 會使用 32 位的 OOP，而不是 64 位的 OOP。
37）怎樣通過 Java 程式來判斷 JVM 是 32 位 還是 64 位？
你可以檢查某些系統屬性如 sun.arch.data.model 或 os.arch 來擷取該資訊。
38）32 位 JVM 和 64 位 JVM 的最大堆記憶體分别是多數？
理論上說上 32 位的 JVM 堆記憶體可以到達 2^32，即 4GB，但實際上會比這個小很多。不同作業系統之間不同，如 Windows 系統大約 1.5 GB，Solaris 大約 3GB。64 位 JVM允許指定最大的堆記憶體，理論上可以達到 2^64，這是一個非常大的數字，實際上你可以指定堆記憶體大小到 100GB。甚至有的 JVM，如 Azul，堆記憶體到 1000G 都是可能的。
39）JRE、JDK、JVM 及 JIT 之間有什麼不同？
JRE 代表 Java 運作時（Java run-time），是運作 Java 應用所必須的。JDK 代表 Java 開發工具（Java development kit），是 Java 程式的開發工具，如 Java 編譯器，它也包含 JRE。JVM 代表 Java 虛拟機（Java virtual machine），它的責任是運作 Java 應用。JIT 代表即時編譯（Just In Time compilation），當代碼執行的次數超過一定的門檻值時，會将 Java 位元組碼轉換為本地代碼，如，主要的熱點代碼會被準換為本地代碼，這樣有利大幅度提高 Java 應用的性能。
3 年工作經驗的 Java 面試題
40）解釋 Java 堆空間及 GC？
當通過 Java 指令啟動 Java 程序的時候，會為它配置設定記憶體。記憶體的一部分用于建立堆空間，當程式中建立對象的時候，就從對空間中配置設定記憶體。GC 是 JVM 内部的一個程序，回收無效對象的記憶體用于将來的配置設定。
JVM 底層面試題及答案
41）你能保證 GC 執行嗎？
不能，雖然你可以調用 System.gc() 或者 Runtime.getRuntime().gc()，但是沒有辦法保證 GC 的執行。
42）怎麼擷取 Java 程式使用的記憶體？堆使用的百分比？
可以通過 java.lang.Runtime 類中與記憶體相關方法來擷取剩餘的記憶體，總記憶體及最大堆記憶體。通過這些方法你也可以擷取到堆使用的百分比及堆記憶體的剩餘空間。Runtime.freeMemory() 方法傳回剩餘空間的位元組數，Runtime.totalMemory() 方法總記憶體的位元組數，Runtime.maxMemory() 傳回最大記憶體的位元組數。
43）Java 中堆和棧有什麼差別？
JVM 中堆和棧屬于不同的記憶體區域，使用目的也不同。棧常用于儲存方法幀和局部變量，而對象總是在堆上配置設定。棧通常都比堆小，也不會在多個線程之間共享，而堆被整個 JVM 的所有線程共享。 Difference between stack and heap memory in Java
關于記憶體的的面試問題和答案
Java 基本概念面試題
44）“a==b”和”a.equals(b)”有什麼差別？
如果 a 和 b 都是對象，則 a==b 是比較兩個對象的引用，隻有當 a 和 b 指向的是堆中的同一個對象才會傳回 true，而 a.equals(b) 是進行邏輯比較，是以通常需要重寫該方法來提供邏輯一緻性的比較。例如，String 類重寫 equals() 方法，是以可以用于兩個不同對象，但是包含的字母相同的比較。
45）a.hashCode() 有什麼用？與 a.equals(b) 有什麼關系？
hashCode() 方法是相應對象整型的 hash 值。它常用于基于 hash 的集合類，如 Hashtable、HashMap、LinkedHashMap等等。它與 equals() 方法關系特别緊密。根據 Java 規範，兩個使用 equal() 方法來判斷相等的對象，必須具有相同的 hash code。
46）final、finalize 和 finally 的不同之處？
final 是一個修飾符，可以修飾變量、方法和類。如果 final 修飾變量，意味着該變量的值在初始化後不能被改變。Java 技術允許使用 finalize() 方法在垃圾收集器将對象從記憶體中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在确定這個對象沒有被引用時對這個對象調用的，但是什麼時候調用 finalize 沒有保證。finally 是一個關鍵字，與 try 和 catch 一起用于異常的處理。finally 塊一定會被執行，無論在 try 塊中是否有發生異常。
47）Java 中的編譯期常量是什麼？使用它又什麼風險？
公共靜态不可變（public static final ）變量也就是我們所說的編譯期常量，這裡的 public 可選的。實際上這些變量在編譯時會被替換掉，因為編譯器知道這些變量的值，并且知道這些變量在運作時不能改變。這種方式存在的一個問題是你使用了一個内部的或第三方庫中的公有編譯時常量，但是這個值後面被其他人改變了，但是你的用戶端仍然在使用老的值，甚至你已經部署了一個新的jar。為了避免這種情況，當你在更新依賴 JAR 檔案時，確定重新編譯你的程式。
Java 集合架構的面試題
這部分也包含資料結構、算法及數組的面試問題
48) List、Set、Map 和 Queue 之間的差別(答案)
List 是一個有序集合，允許元素重複。它的某些實作可以提供基于下标值的常量通路時間，但是這不是 List 接口保證的。Set 是一個無序集合。
49）poll() 方法和 remove() 方法的差別？
poll() 和 remove() 都是從隊列中取出一個元素，但是 poll() 在擷取元素失敗的時候會傳回空，但是 remove() 失敗的時候會抛出異常。
50）Java 中 LinkedHashMap 和 PriorityQueue 的差別是什麼？(答案)
PriorityQueue 保證最高或者最低優先級的的元素總是在隊列頭部，但是 LinkedHashMap 維持的順序是元素插入的順序。當周遊一個 PriorityQueue 時，沒有任何順序保證，但是 LinkedHashMap 課保證周遊順序是元素插入的順序。
51）ArrayList 與 LinkedList 的不差別？(答案)
最明顯的差別是 ArrrayList 底層的資料結構是數組，支援随機通路，而 LinkedList 的底層資料結構書連結清單，不支援随機通路。使用下标通路一個元素，ArrayList 的時間複雜度是 O(1)，而 LinkedList 是 O(n)。更多細節的讨論參見答案。
52）用哪兩種方式來實作集合的排序？(答案)
你可以使用有序集合，如 TreeSet 或 TreeMap，你也可以使用有順序的的集合，如 list，然後通過 Collections.sort() 來排序。
53）Java 中怎麼列印數組？(answer答案)
你可以使用 Arrays.toString() 和 Arrays.deepToString() 方法來列印數組。由于數組沒有實作 toString() 方法，是以如果将數組傳遞給 System.out.println() 方法，将無法列印出數組的内容，但是 Arrays.toString() 可以列印每個元素。
54）Java 中的 LinkedList 是單向連結清單還是雙向連結清單？(答案)
是雙向連結清單，你可以檢查 JDK 的源碼。在 Eclipse，你可以使用快捷鍵 Ctrl + T，直接在編輯器中打開該類。
55）Java 中的 TreeMap 是采用什麼樹實作的？(答案)
Java 中的 TreeMap 是使用紅黑樹實作的。
56) Hashtable 與 HashMap 有什麼不同之處？(答案)
這兩個類有許多不同的地方，下面列出了一部分： a) Hashtable 是 JDK 1 遺留下來的類，而 HashMap 是後來增加的。 b）Hashtable 是同步的，比較慢，但 HashMap 沒有同步政策，是以會更快。 c）Hashtable 不允許有個空的 key，但是 HashMap 允許出現一個 null key。 更多的不同之處參見答案。
57）Java 中的 HashSet，内部是如何工作的？(answer答案)
HashSet 的内部采用 HashMap來實作。由于 Map 需要 key 和 value，是以所有 key 的都有一個預設 value。類似于 HashMap，HashSet 不允許重複的 key，隻允許有一個null key，意思就是 HashSet 中隻允許存儲一個 null 對象。
58）寫一段代碼在周遊 ArrayList 時移除一個元素？(答案)
該問題的關鍵在于面試者使用的是 ArrayList 的 remove() 還是 Iterator 的 remove()方法。這有一段示例代碼，是使用正确的方式來實作在周遊的過程中移除元素，而不會出現 ConcurrentModificationException 異常的示例代碼。
59）我們能自己寫一個容器類，然後使用 for-each 循環嗎？
可以，你可以寫一個自己的容器類。如果你想使用 Java 中增強的循環來周遊，你隻需要實作 Iterable 接口。如果你實作 Collection 接口，預設就具有該屬性。
60）ArrayList 和 HashMap 的預設大小是多數？(答案)
在 Java 7 中，ArrayList 的預設大小是 10 個元素，HashMap 的預設大小是16個元素（必須是2的幂）。這就是 Java 7 中 ArrayList 和 HashMap 類的代碼片段：
// from ArrayList.java JDK 1.7
private static final int DEFAULT_CAPACITY = 10;
//from HashMap.java JDK 7
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
61）有沒有可能兩個不相等的對象有有相同的 hashcode？
有可能，兩個不相等的對象可能會有相同的 hashcode 值，這就是為什麼在 hashmap 中會有沖突。相等 hashcode 值的規定隻是說如果兩個對象相等，必須有相同的hashcode 值，但是沒有關于不相等對象的任何規定。
62）兩個相同的對象會有不同的的 hash code 嗎？
不能，根據 hash code 的規定，這是不可能的。
63）我們可以在 hashcode() 中使用随機數字嗎？(答案)
不行，因為對象的 hashcode 值必須是相同的。參見答案擷取更多關于 Java 中重寫 hashCode() 方法的知識。
64）Java 中，Comparator 與 Comparable 有什麼不同？(答案)
Comparable 接口用于定義對象的自然順序，而 comparator 通常用于定義使用者定制的順序。Comparable 總是隻有一個，但是可以有多個 comparator 來定義對象的順序。
65）為什麼在重寫 equals 方法的時候需要重寫 hashCode 方法？(答案)
因為有強制的規範指定需要同時重寫 hashcode 與 equal 是方法，許多容器類，如 HashMap、HashSet 都依賴于 hashcode 與 equals 的規定。
Java IO 和 NIO 的面試題
IO 是 Java 面試中一個非常重要的點。你應該很好掌握 Java IO，NIO，NIO2 以及與作業系統，磁盤 IO 相關的基礎知識。下面是 Java IO 中經常問的問題。
66）在我 Java 程式中，我有三個 socket，我需要多少個線程來處理？
67）Java 中怎麼建立 ByteBuffer？
68）Java 中，怎麼讀寫 ByteBuffer ？
69）Java 采用的是大端還是小端？
70）ByteBuffer 中的位元組序是什麼？
71）Java 中，直接緩沖區與非直接緩沖器有什麼差別？(答案)
72）Java 中的記憶體映射緩存區是什麼？(answer答案)
73）socket 選項 TCP NO DELAY 是指什麼？
74）TCP 協定與 UDP 協定有什麼差別？(answer答案)
75）Java 中，ByteBuffer 與 StringBuffer有什麼差別？(答案)
Java 最佳實踐的面試問題
包含 Java 中各個部分的最佳實踐，如集合，字元串，IO，多線程，錯誤和異常處理，設計模式等等。
76）Java 中，編寫多線程程式的時候你會遵循哪些最佳實踐？(答案)
這是我在寫Java 并發程式的時候遵循的一些最佳實踐： a）給線程命名，這樣可以幫助調試。 b）最小化同步的範圍，而不是将整個方法同步，隻對關鍵部分做同步。 c）如果可以，更偏向于使用 volatile 而不是 synchronized。 d）使用更高層次的并發工具，而不是使用 wait() 和 notify() 來實作線程間通信，如 BlockingQueue，CountDownLatch 及 Semeaphore。 e）優先使用并發集合，而不是對集合進行同步。并發集合提供更好的可擴充性。
77）說出幾點 Java 中使用 Collections 的最佳實踐(答案)
這是我在使用 Java 中 Collectionc 類的一些最佳實踐： a）使用正确的集合類，例如，如果不需要同步清單，使用 ArrayList 而不是 Vector。 b）優先使用并發集合，而不是對集合進行同步。并發集合提供更好的可擴充性。 c）使用接口代表和通路集合，如使用List存儲 ArrayList，使用 Map 存儲 HashMap 等等。 d）使用疊代器來循環集合。 e）使用集合的時候使用泛型。
78）說出至少 5 點在 Java 中使用線程的最佳實踐。(答案)
這個問題與之前的問題類似，你可以使用上面的答案。對線程來說，你應該： a）對線程命名 b）将線程和任務分離，使用線程池執行器來執行 Runnable 或 Callable。 c）使用線程池
79）說出 5 條 IO 的最佳實踐(答案)
IO 對 Java 應用的性能非常重要。理想情況下，你不應該在你應用的關鍵路徑上避免 IO 操作。下面是一些你應該遵循的 Java IO 最佳實踐： a）使用有緩沖區的 IO 類，而不要單獨讀取位元組或字元。 b）使用 NIO 和 NIO2 c）在 finally 塊中關閉流，或者使用 try-with-resource（Java7） 語句。 d）使用記憶體映射檔案擷取更快的 IO。
80）列出 5 個應該遵循的 JDBC 最佳實踐(答案)
有很多的最佳實踐，你可以根據你的喜好來例舉。下面是一些更通用的原則： a）使用批量的操作來插入和更新資料 b）使用 PreparedStatement 來避免 SQL 異常，并提高性能。 c）使用資料庫連接配接池 d）通過列名來擷取結果集，不要使用列的下标來擷取。
81）說出幾條 Java 中方法重載的最佳實踐？(答案)
下面有幾條可以遵循的方法重載的最佳實踐來避免造成自動裝箱的混亂。 a）不要重載這樣的方法：一個方法接收 int 參數，而另個方法接收 Integer 參數。 b）不要重載參數數量一緻，而隻是參數順序不同的方法。 c）如果重載的方法參數個數多于 5 個，采用可變參數。
Date、Time 及 Calendar 的面試題
82）在多線程環境下，SimpleDateFormat 是線程安全的嗎？(答案)
不是，非常不幸，DateFormat 的所有實作，包括 SimpleDateFormat 都不是線程安全的，是以你不應該在多線程式中使用，除非是在對外線程安全的環境中使用，如 将 SimpleDateFormat 限制在 ThreadLocal 中。如果你不這麼做，在解析或者格式化日期的時候，可能會擷取到一個不正确的結果。是以，從日期、時間處理的所有實踐來說，我強力推薦 joda-time 庫。
83）Java 中如何格式化一個日期？如格式化為 ddMMyyyy 的形式？(答案)
Java 中，可以使用 SimpleDateFormat 類或者 joda-time 庫來格式日期。DateFormat 類允許你使用多種流行的格式來格式化日期。參見答案中的示例代碼，代碼中示範了将日期格式化成不同的格式，如 dd-MM-yyyy 或 ddMMyyyy。
84）Java 中，怎麼在格式化的日期中顯示時區？
pattern中加z yyyy-MM-dd HH:mm:ss.SSS Z
85）Java 中 java.util.Date 與 java.sql.Date 有什麼差別？
java.sql.Date是針對SQL語句使用的，它隻包含日期而沒有時間部分,它們都有getTime方法傳回毫秒數，自然就可以直接建構。java.util.Date 是 java.sql.Date 的父類，前者是常用的表示時間的類，我們通常格式化或者得到目前時間都是用他，後者之後在讀寫資料庫的時候用他，因為PreparedStament的setDate()的第2參數和ResultSet的getDate()方法的第2個參數都是java.sql.Date。
86）Java 中，如何計算兩個日期之間的差距？
public static int dateDiff(Date d1, Date d2) throws Exception {
long n1 = d1.getTime();
long n2 = d2.getTime();
long diff = Math.abs(n1 - n2);
diff /= 3600 * 1000 * 24;
return diff;
}
87）Java 中，如何将字元串 YYYYMMDD 轉換為日期？
SimpleDateFormat的parse方法
單元測試 JUnit 面試題
89）如何測試靜态方法？(答案)
可以使用 PowerMock 庫來測試靜态方法。
90）怎麼利用 JUnit 來測試一個方法的異常？(答案)
91）你使用過哪個單元測試庫來測試你的 Java 程式？(答案)
92）@Before 和 @BeforeClass 有什麼差別？(答案)
程式設計和代碼相關的面試題
93）怎麼檢查一個字元串隻包含數字？(解決方案)
94）Java 中如何利用泛型寫一個 LRU 緩存？(答案)
95）寫一段 Java 程式将 byte 轉換為 long？(答案)
95）在不使用 StringBuffer 的前提下，怎麼反轉一個字元串？(解決方案)
97）Java 中，怎麼擷取一個檔案中單詞出現的最高頻率？(解決方案)
98）如何檢查出兩個給定的字元串是反序的？(解決方案)
99）Java 中，怎麼列印出一個字元串的所有排列？(解決方案)
100）Java 中，怎樣才能列印出數組中的重複元素？(解決方案)
101）Java 中如何将字元串轉換為整數？(解決方案)
102）在沒有使用臨時變量的情況如何交換兩個整數變量的值？(解決方案)
交換兩個值，不用臨時變量?我們通過位運算中的異或來實作。 //測試代碼為C語言代碼
前置知識：
1.一個整數自己跟自己異或，結果為0 //因為異或的法則為，相同為0，不同為1，注意這裡所說的都是二進制位。
2.任意一個整數跟0異或，結果為本身。 //因為1異或0得1,0異或0,得0，是以1還是1,0還是0，沒發生變化。
------------------------------------------------------------------------------------------------------
測試代碼如下：
- int main(int argc, char* argv[])
- {
- int a=575,b=667;
- a=a^b;
- b=a^b;
- printf("a=%d b=%d \n",a,b);
- getchar();
- return 0;
- }
-----------------------------------------------------------------------------------------------------------------------------------
//效果截圖如下：
---------------------------------------------------------------------------------------------------------------------------------
分析下a和b發生交換的原因：
根據以上代碼不難得出以下表達式:
1. b=(a^b)^b=a^b^b=a
2. a=(a^b)^[(a^b)^b]=a^b^[a^b^b]=a^b^a^b^b=a^a^b^b^b=b
根據前面說的前置知識，不難明白a和b，為什麼發生交換了。
關于 OOP 和設計模式的面試題
這部分包含 Java 面試過程中關于 SOLID 的設計原則，OOP 基礎，如類，對象，接口，繼承，多态，封裝，抽象以及更進階的一些概念，如組合、聚合及關聯。也包含了 GOF 設計模式的問題。
103）接口是什麼？為什麼要使用接口而不是直接使用具體類？
接口用于定義 API。它定義了類必須得遵循的規則。同時，它提供了一種抽象，因為用戶端隻使用接口，這樣可以有多重實作，如 List 接口，你可以使用可随機通路的 ArrayList，也可以使用友善插入和删除的 LinkedList。接口中不允許寫代碼，以此來保證抽象，但是 Java 8 中你可以在接口聲明靜态的預設方法，這種方法是具體的。
104）Java 中，抽象類與接口之間有什麼不同？(答案)
Java 中，抽象類和接口有很多不同之處，但是最重要的一個是 Java 中限制一個類隻能繼承一個類，但是可以實作多個接口。抽象類可以很好的定義一個家族類的預設行為，而接口能更好的定義類型，有助于後面實作多态機制。關于這個問題的讨論請檢視答案。
105）除了單例模式，你在生産環境中還用過什麼設計模式？
這需要根據你的經驗來回答。一般情況下，你可以說依賴注入，工廠模式，裝飾模式或者觀察者模式，随意選擇你使用過的一種即可。不過你要準備回答接下的基于你選擇的模式的問題。
106）你能解釋一下裡氏替換原則嗎?(答案)
107) 什麼情況下會違反迪米特法則？為什麼會有這個問題？(答案)
迪米特法則建議“隻和朋友說話，不要陌生人說話”，以此來減少類之間的耦合。
108）擴充卡模式是什麼？什麼時候使用？
擴充卡模式提供對接口的轉換。如果你的用戶端使用某些接口，但是你有另外一些接口，你就可以寫一個适配去來連接配接這些接口。
109）什麼是“依賴注入”和“控制反轉”？為什麼有人使用？(答案)
110）抽象類是什麼？它與接口有什麼差別？你為什麼要使用過抽象類？(答案)
抽象方法：由abstract修飾的方法為抽象方法，抽象方法隻有方法的定義，沒有方法的實作。
抽象類：一個類中如果包含抽象方法，個i類應該用abstract關鍵字聲明為抽象類。
抽象類不可以執行個體化，即使一個類中沒有抽象方法，也可以将其定義為抽象類，同樣，該類不可以執行個體化。
抽象類的意義：
1，為子類提供一個公共的類型；
2，封裝子類中重複内容（成員變量和方法）；
3，定義有抽象方法，子類雖然有不同的實作，但該方法的定義是一緻的。
抽象類和接口的差別：
抽象類：為了被子類繼承，為子類提供了同一的方法入口；
接口：定義了一個标準（特殊的抽象類）。 111）構造器注入和 setter 依賴注入，那種方式更好？(答案)
每種方式都有它的缺點和優點。構造器注入保證所有的注入都被初始化，但是 setter 注入提供更好的靈活性來設定可選依賴。如果使用 XML 來描述依賴，Setter 注入的可讀寫會更強。經驗法則是強制依賴使用構造器注入，可選依賴使用 setter 注入。
112）依賴注入和工廠模式之間有什麼不同？(答案)
雖然兩種模式都是将對象的建立從應用的邏輯中分離，但是依賴注入比工程模式更清晰。通過依賴注入，你的類就是 POJO，它隻知道依賴而不關心它們怎麼擷取。使用工廠模式，你的類需要通過工廠來擷取依賴。是以，使用 DI 會比使用工廠模式更容易測試。關于這個話題的更詳細讨論請參見答案。
113）擴充卡模式和裝飾器模式有什麼差別？(答案)
雖然擴充卡模式和裝飾器模式的結構類似，但是每種模式的出現意圖不同。擴充卡模式被用于橋接兩個接口，而裝飾模式的目的是在不修改類的情況下給類增加新的功能。
114）擴充卡模式和代理模式之前有什麼不同？(答案)
這個問題與前面的類似，擴充卡模式和代理模式的差別在于他們的意圖不同。由于擴充卡模式和代理模式都是封裝真正執行動作的類，是以結構是一緻的，但是擴充卡模式用于接口之間的轉換，而代理模式則是增加一個額外的中間層，以便支援配置設定、控制或智能通路。
115）什麼是模闆方法模式？(答案)
模闆方法提供算法的架構，你可以自己去配置或定義步驟。例如，你可以将排序算法看做是一個模闆。它定義了排序的步驟，但是具體的比較，可以使用 Comparable 或者其語言中類似東西，具體政策由你去配置。列出算法概要的方法就是衆所周知的模闆方法。
116）什麼時候使用通路者模式？(答案)
通路者模式用于解決在類的繼承層次上增加操作，但是不直接與之關聯。這種模式采用雙派發的形式來增加中間層。
117）什麼時候使用組合模式？(答案)
組合模式使用樹結構來展示部分與整體繼承關系。它允許用戶端采用統一的形式來對待單個對象和對象容器。當你想要展示對象這種部分與整體的繼承關系時采用組合模式。
118）繼承群組合之間有什麼不同？(答案)
雖然兩種都可以實作代碼複用，但是組合比繼承共靈活，因為組合允許你在運作時選擇不同的實作。用組合實作的代碼也比繼承測試起來更加簡單。
119）描述 Java 中的重載和重寫？(答案)
重載和重寫都允許你用相同的名稱來實作不同的功能，但是重載是編譯時活動，而重寫是運作時活動。你可以在同一個類中重載方法，但是隻能在子類中重寫方法。重寫必須要有繼承。
120）Java 中，嵌套公共靜态類與頂級類有什麼不同？(答案)
類的内部可以有多個嵌套公共靜态類，但是一個 Java 源檔案隻能有一個頂級公共類，并且頂級公共類的名稱與源檔案名稱必須一緻。
121) OOP 中的 組合、聚合和關聯有什麼差別？(答案)
如果兩個對象彼此有關系，就說他們是彼此相關聯的。組合和聚合是面向對象中的兩種形式的關聯。組合是一種比聚合更強力的關聯。組合中，一個對象是另一個的擁有者，而聚合則是指一個對象使用另一個對象。如果對象 A 是由對象 B 組合的，則 A 不存在的話，B一定不存在，但是如果 A 對象聚合了一個對象 B，則即使 A 不存在了，B 也可以單獨存在。
122）給我一個符合開閉原則的設計模式的例子？(答案)
開閉原則要求你的代碼對擴充開放，對修改關閉。這個意思就是說，如果你想增加一個新的功能，你可以很容易的在不改變已測試過的代碼的前提下增加新的代碼。有好幾個設計模式是基于開閉原則的，如政策模式，如果你需要一個新的政策，隻需要實作接口，增加配置，不需要改變核心邏輯。一個正在工作的例子是 Collections.sort() 方法，這就是基于政策模式，遵循開閉原則的，你不需為新的對象修改 sort() 方法，你需要做的僅僅是實作你自己的 Comparator 接口。
123）抽象工廠模式和原型模式之間的差別？(答案)
124）什麼時候使用享元模式？(答案)
享元模式通過共享對象來避免建立太多的對象。為了使用享元模式，你需要確定你的對象是不可變的，這樣你才能安全的共享。JDK 中 String 池、Integer 池以及 Long 池都是很好的使用了享元模式的例子。
Java 面試中其他各式各樣的問題
這部分包含 Java 中關于 XML 的面試題，JDBC 面試題，正規表達式面試題，Java 錯誤和異常及序列化面試題
125）嵌套靜态類與頂級類有什麼差別？(答案)
一個公共的頂級類的源檔案名稱與類名相同，而嵌套靜态類沒有這個要求。一個嵌套類位于頂級類内部，需要使用頂級類的名稱來引用嵌套靜态類，如 HashMap.Entry 是一個嵌套靜态類，HashMap 是一個頂級類，Entry是一個嵌套靜态類。
126）你能寫出一個正規表達式來判斷一個字元串是否是一個數字嗎？(解決方案)
一個數字字元串，隻能包含數字，如 0 到 9 以及 +、- 開頭，通過這個資訊，你可以下一個如下的正規表達式來判斷給定的字元串是不是數字。
127）Java 中，受檢查異常 和 不受檢查異常的差別？(答案)
受檢查異常編譯器在編譯期間檢查。對于這種異常，方法強制處理或者通過 throws 子句聲明。其中一種情況是 Exception 的子類但不是 RuntimeException 的子類。非受檢查是 RuntimeException 的子類，在編譯階段不受編譯器的檢查。
128）Java 中，throw 和 throws 有什麼差別？(答案)
throw 用于抛出 java.lang.Throwable 類的一個執行個體化對象，意思是說你可以通過關鍵字 throw 抛出一個 Error 或者 一個Exception，如： throw new IllegalArgumentException(“size must be multiple of 2″) 而throws 的作用是作為方法聲明和簽名的一部分，方法被抛出相應的異常以便調用者能處理。Java 中，任何未處理的受檢查異常強制在 throws 子句中聲明。
129）Java 中，Serializable 與 Externalizable 的差別？(答案)
Serializable 接口是一個序列化 Java 類的接口，以便于它們可以在網絡上傳輸或者可以将它們的狀态儲存在磁盤上，是 JVM 内嵌的預設序列化方式，成本高、脆弱而且不安全。Externalizable 允許你控制整個序列化過程，指定特定的二進制格式，增加安全機制。
130）Java 中，DOM 和 SAX 解析器有什麼不同？(答案)
DOM 解析器将整個 XML 文檔加載到記憶體來建立一棵 DOM 模型樹，這樣可以更快的查找節點和修改 XML 結構，而 SAX 解析器是一個基于事件的解析器，不會将整個 XML 文檔加載到記憶體。由于這個原因，DOM 比 SAX 更快，也要求更多的記憶體，不适合于解析大 XML 檔案。
131）說出 JDK 1.7 中的三個新特性？(答案)
雖然 JDK 1.7 不像 JDK 5 和 8 一樣的大版本，但是，還是有很多新的特性，如 try-with-resource 語句，這樣你在使用流或者資源的時候，就不需要手動關閉，Java 會自動關閉。Fork-Join 池某種程度上實作 Java 版的 Map-reduce。允許 Switch 中有 String 變量和文本。菱形操作符(<>)用于類型推斷，不再需要在變量聲明的右邊申明泛型，是以可以寫出可讀寫更強、更簡潔的代碼。另一個值得一提的特性是改善異常處理，如允許在同一個 catch 塊中捕獲多個異常。
132）說出 5 個 JDK 1.8 引入的新特性？(答案)
Java 8 在 Java 曆史上是一個開創新的版本，下面 JDK 8 中 5 個主要的特性： Lambda 表達式，允許像對象一樣傳遞匿名函數 Stream API，充分利用現代多核 CPU，可以寫出很簡潔的代碼 Date 與 Time API，最終，有一個穩定、簡單的日期和時間庫可供你使用 擴充方法，現在，接口中可以有靜态、預設方法。 重複注解，現在你可以将相同的注解在同一類型上使用多次。
133）Java 中，Maven 和 ANT 有什麼差別？(答案)
雖然兩者都是建構工具，都用于建立 Java 應用，但是 Maven 做的事情更多，在基于“約定優于配置”的概念下，提供标準的Java 項目結構，同時能為應用自動管理依賴（應用中所依賴的 JAR 檔案），Maven 與 ANT 工具更多的不同之處請參見答案。
這就是所有的面試題，如此之多，是不是？我可以保證，如果你能回答清單中的所有問題，你就可以很輕松的應付任何核心 Java 或者進階 Java 面試。雖然，這裡沒有涵蓋 Servlet、JSP、JSF、JPA，JMS，EJB 及其它 Java EE 技術，也沒有包含主流的架構如 Spring MVC，Struts 2.0，Hibernate，也沒有包含 SOAP 和 RESTful web service，但是這份清單對做 Java 開發的、準備應聘 Java web 開發職位的人還是同樣有用的，因為所有的 Java 面試，開始的問題都是 Java 基礎和 JDK API 相關的。如果你認為我這裡有任何應該在這份清單中而被我遺漏了的 Java 流行的問題，你可以自由的給我建議。我的目的是從最近的面試中建立一份最新的、最優的 Java 面試問題清單。
50道Java線程面試題分析及答案
下面是Java線程相關的熱門面試題，你可以用它來好好準備面試。
1) 什麼是線程？
線程是作業系統能夠進行運算排程的最小機關，它被包含在程序之中，是程序中的實際運作機關。程式員可以通過它進行多處理器程式設計，你可以使用多線程對運算密集型任務提速。比如，如果一個線程完成一個任務要100毫秒，那麼用十個線程完成改任務隻需10毫秒。Java在語言層面對多線程提供了卓越的支援，它也是一個很好的賣點。
2) 線程和程序有什麼差別？
線程是程序的子集，一個程序可以有很多線程，每條線程并行執行不同的任務。不同的程序使用不同的記憶體空間，而所有的線程共享一片相同的記憶體空間。别把它和棧記憶體搞混，每個線程都擁有單獨的棧記憶體用來存儲本地資料。
3) 如何在Java中實作線程？
在語言層面有兩種方式。java.lang.Thread 類的執行個體就是一個線程但是它需要調用java.lang.Runnable接口來執行，由于線程類本身就是調用的Runnable接口是以你可以繼承java.lang.Thread 類或者直接調用Runnable接口來重寫run()方法實作線程。
4) 用Runnable還是Thread？
這個問題是上題的後續，大家都知道我們可以通過繼承Thread類或者調用Runnable接口來實作線程，問題是，那個方法更好呢？什麼情況下使用它？這個問題很容易回答，如果你知道Java不支援類的多重繼承，但允許你調用多個接口。是以如果你要繼承其他類，當然是調用Runnable接口好了。
5) Thread 類中的start() 和 run() 方法有什麼差別？
這個問題經常被問到，但還是能從此區分出面試者對Java線程模型的了解程度。start()方法被用來啟動新建立的線程，而且start()内部調用了run()方法，這和直接調用run()方法的效果不一樣。當你調用run()方法的時候，隻會是在原來的線程中調用，沒有新的線程啟動，start()方法才會啟動新線程。
6) Java中Runnable和Callable有什麼不同？
Runnable和Callable都代表那些要在不同的線程中執行的任務。Runnable從JDK1.0開始就有了，Callable是在JDK1.5增加的。它們的主要差別是Callable的 call() 方法可以傳回值和抛出異常，而Runnable的run()方法沒有這些功能。Callable可以傳回裝載有計算結果的Future對象。
7）如何強制啟動一個線程？
這個問題就像是如何強制進行Java垃圾回收，目前還沒有覺得方法，雖然你可以使用System.gc()來進行垃圾回收，但是不保證能成功。在Java裡面沒有辦法強制啟動一個線程，它是被線程排程器控制着且Java沒有公布相關的API。
8) Java中CyclicBarrier 和 CountDownLatch有什麼不同？
CyclicBarrier 和 CountDownLatch 都可以用來讓一組線程等待其它線程。與 CyclicBarrier 不同的是，CountdownLatch 不能重新使用。
9) Java記憶體模型是什麼？
Java記憶體模型規定和指引Java程式在不同的記憶體架構、CPU和作業系統間有确定性地行為。它在多線程的情況下尤其重要。Java記憶體模型對一個線程所做的變動能被其它線程可見提供了保證，它們之間是先行發生關系。這個關系定義了一些規則讓程式員在并發程式設計時思路更清晰。比如，先行發生關系確定了：
線程内的代碼能夠按先後順序執行，這被稱為程式次序規則。
對于同一個鎖，一個解鎖操作一定要發生在時間上後發生的另一個鎖定操作之前，也叫做管程鎖定規則。
前一個對volatile的寫操作在後一個volatile的讀操作之前，也叫volatile變量規則。
一個線程内的任何操作必需在這個線程的start()調用之後，也叫作線程啟動規則。
一個線程的所有操作都會線上程終止之前，線程終止規則。
一個對象的終結操作必需在這個對象構造完成之後，也叫對象終結規則。
可傳遞性
10) Java中的volatile 變量是什麼？
volatile是一個特殊的修飾符，隻有成員變量才能使用它。在Java并發程式缺少同步類的情況下，多線程對成員變量的操作對其它線程是透明的。volatile變量可以保證下一個讀取操作會在前一個寫操作之後發生，就是上一題的volatile變量規則。點選這裡檢視更多volatile的相關内容。
11) 什麼是線程安全？Vector是一個線程安全類嗎？
如果你的代碼所在的程序中有多個線程在同時運作，而這些線程可能會同時運作這段代碼。如果每次運作結果和單線程運作的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。一個線程安全的計數器類的同一個執行個體對象在被多個線程使用的情況下也不會出現計算失誤。很顯然你可以将集合類分成兩組，線程安全和非線程安全的。Vector 是用同步方法來實作線程安全的, 而和它相似的ArrayList不是線程安全的。
12) Java中什麼是競态條件？ 舉個例子說明。
競态條件會導緻程式在并發情況下出現一些bugs。多線程對一些資源的競争的時候就會産生競态條件，如果首先要執行的程式競争失敗排到後面執行了，那麼整個程式就會出現一些不确定的bugs。這種bugs很難發現而且會重複出現，因為線程間的随機競争。
13) Java中如何停止一個線程？
Java提供了很豐富的API但沒有為停止線程提供API。JDK 1.0本來有一些像stop(), suspend() 和 resume()的控制方法但是由于潛在的死鎖威脅是以在後續的JDK版本中他們被棄用了，之後Java API的設計者就沒有提供一個相容且線程安全的方法來停止一個線程。當run() 或者 call() 方法執行完的時候線程會自動結束,如果要手動結束一個線程，你可以用volatile 布爾變量來退出run()方法的循環或者是取消任務來中斷線程。
14) 一個線程運作時發生異常會怎樣？
這是我在一次面試中遇到的一個很刁鑽的Java面試題, 簡單的說，如果異常沒有被捕獲該線程将會停止執行。Thread.UncaughtExceptionHandler是用于處理未捕獲異常造成線程突然中斷情況的一個内嵌接口。當一個未捕獲異常将造成線程中斷的時候JVM會使用Thread.getUncaughtExceptionHandler()來查詢線程的UncaughtExceptionHandler并将線程和異常作為參數傳遞給handler的uncaughtException()方法進行處理。
15） 如何在兩個線程間共享資料？
你可以通過共享對象來實作這個目的，或者是使用像阻塞隊列這樣并發的資料結構。這篇教程《Java線程間通信》(涉及到在兩個線程間共享對象)用wait和notify方法實作了生産者消費者模型。
16) Java中notify 和 notifyAll有什麼差別？
這又是一個刁鑽的問題，因為多線程可以等待單監控鎖，Java API 的設計人員提供了一些方法當等待條件改變的時候通知它們，但是這些方法沒有完全實作。notify()方法不能喚醒某個具體的線程，是以隻有一個線程在等待的時候它才有用武之地。而notifyAll()喚醒所有線程并允許他們争奪鎖確定了至少有一個線程能繼續運作。
17) 為什麼wait, notify 和 notifyAll這些方法不在thread類裡面？
這是個設計相關的問題，它考察的是面試者對現有系統和一些普遍存在但看起來不合理的事物的看法。回答這些問題的時候，你要說明為什麼把這些方法放在Object類裡是有意義的，還有不把它放在Thread類裡的原因。一個很明顯的原因是JAVA提供的鎖是對象級的而不是線程級的，每個對象都有鎖，通過線程獲得。如果線程需要等待某些鎖那麼調用對象中的wait()方法就有意義了。如果wait()方法定義在Thread類中，線程正在等待的是哪個鎖就不明顯了。簡單的說，由于wait，notify和notifyAll都是鎖級别的操作，是以把他們定義在Object類中因為鎖屬于對象你也可以檢視這篇文章了解更多。
18) 什麼是ThreadLocal變量？
ThreadLocal是Java裡一種特殊的變量。每個線程都有一個ThreadLocal就是每個線程都擁有了自己獨立的一個變量，競争條件被徹底消除了。它是為建立代價高昂的對象擷取線程安全的好方法，比如你可以用ThreadLocal讓SimpleDateFormat變成線程安全的，因為那個類建立代價高昂且每次調用都需要建立不同的執行個體是以不值得在局部範圍使用它，如果為每個線程提供一個自己獨有的變量拷貝，将大大提高效率。首先，通過複用減少了代價高昂的對象的建立個數。其次，你在沒有使用高代價的同步或者不變性的情況下獲得了線程安全。線程局部變量的另一個不錯的例子是ThreadLocalRandom類，它在多線程環境中減少了建立代價高昂的Random對象的個數。
19) 什麼是FutureTask？
在Java并發程式中FutureTask表示一個可以取消的異步運算。它有啟動和取消運算、查詢運算是否完成和取回運算結果等方法。隻有當運算完成的時候結果才能取回，如果運算尚未完成get方法将會阻塞。一個FutureTask對象可以對調用了Callable和Runnable的對象進行包裝，由于FutureTask也是調用了Runnable接口是以它可以送出給Executor來執行。
20) Java中interrupted 和 isInterruptedd方法的差別？
interrupted() 和 isInterrupted()的主要差別是前者會将中斷狀态清除而後者不會。Java多線程的中斷機制是用内部辨別來實作的，調用Thread.interrupt()來中斷一個線程就會設定中斷辨別為true。當中斷線程調用靜态方法Thread.interrupted()來檢查中斷狀态時，中斷狀态會被清零。而非靜态方法isInterrupted()用來查詢其它線程的中斷狀态且不會改變中斷狀态辨別。簡單的說就是任何抛出InterruptedException異常的方法都會将中斷狀态清零。無論如何，一個線程的中斷狀态有有可能被其它線程調用中斷來改變。
21) 為什麼wait和notify方法要在同步塊中調用？
主要是因為Java API強制要求這樣做，如果你不這麼做，你的代碼會抛出IllegalMonitorStateException異常。還有一個原因是為了避免wait和notify之間産生競态條件。
22) 為什麼你應該在循環中檢查等待條件?
處于等待狀态的線程可能會收到錯誤警報和僞喚醒，如果不在循環中檢查等待條件，程式就會在沒有滿足結束條件的情況下退出。是以，當一個等待線程醒來時，不能認為它原來的等待狀态仍然是有效的，在notify()方法調用之後和等待線程醒來之前這段時間它可能會改變。這就是在循環中使用wait()方法效果更好的原因，你可以在Eclipse中建立模闆調用wait和notify試一試。如果你想了解更多關于這個問題的内容，我推薦你閱讀《Effective Java》這本書中的線程和同步章節。
23) Java中的同步集合與并發集合有什麼差別？
同步集合與并發集合都為多線程和并發提供了合适的線程安全的集合，不過并發集合的可擴充性更高。在Java1.5之前程式員們隻有同步集合來用且在多線程并發的時候會導緻争用，阻礙了系統的擴充性。Java5介紹了并發集合像ConcurrentHashMap，不僅提供線程安全還用鎖分離和内部分區等現代技術提高了可擴充性。
24） Java中堆和棧有什麼不同？
為什麼把這個問題歸類在多線程和并發面試題裡？因為棧是一塊和線程緊密相關的記憶體區域。每個線程都有自己的棧記憶體，用于存儲本地變量，方法參數和棧調用，一個線程中存儲的變量對其它線程是不可見的。而堆是所有線程共享的一片公用記憶體區域。對象都在堆裡建立，為了提升效率線程會從堆中弄一個緩存到自己的棧，如果多個線程使用該變量就可能引發問題，這時volatile 變量就可以發揮作用了，它要求線程從主存中讀取變量的值。
25） 什麼是線程池？ 為什麼要使用它？
建立線程要花費昂貴的資源和時間，如果任務來了才建立線程那麼響應時間會變長，而且一個程序能建立的線程數有限。為了避免這些問題，在程式啟動的時候就建立若幹線程來響應處理，它們被稱為線程池，裡面的線程叫工作線程。從JDK1.5開始，Java API提供了Executor架構讓你可以建立不同的線程池。比如單線程池，每次處理一個任務；數目固定的線程池或者是緩存線程池（一個适合很多生存期短的任務的程式的可擴充線程池）。
26） 如何寫代碼來解決生産者消費者問題？
在現實中你解決的許多線程問題都屬于生産者消費者模型，就是一個線程生産任務供其它線程進行消費，你必須知道怎麼進行線程間通信來解決這個問題。比較低級的辦法是用wait和notify來解決這個問題，比較贊的辦法是用Semaphore 或者 BlockingQueue來實作生産者消費者模型，這篇教程有實作它。
27） 如何避免死鎖？
死鎖是指兩個或兩個以上的程序在執行過程中，因争奪資源而造成的一種互相等待的現象，若無外力作用，它們都将無法推進下去。這是一個嚴重的問題，因為死鎖會讓你的程式挂起無法完成任務，死鎖的發生必須滿足以下四個條件：
互斥條件：一個資源每次隻能被一個程序使用。
請求與保持條件：一個程序因請求資源而阻塞時，對已獲得的資源保持不放。
不剝奪條件：程序已獲得的資源，在末使用完之前，不能強行剝奪。
循環等待條件：若幹程序之間形成一種頭尾相接的循環等待資源關系。
最簡單的方法就是阻止循環等待條件，将系統中所有的資源設定标志位、排序，規定所有的程序申請資源必須以一定的順序（升序或降序）做操作來避免死鎖。這篇教程有代碼示例和避免死鎖的讨論細節。
28) Java中活鎖和死鎖有什麼差別？
這是上題的擴充，活鎖和死鎖類似，不同之處在于處于活鎖的線程或程序的狀态是不斷改變的，活鎖可以認為是一種特殊的饑餓。一個現實的活鎖例子是兩個人在狹小的走廊碰到，兩個人都試着避讓對方好讓彼此通過，但是因為避讓的方向都一樣導緻最後誰都不能通過走廊。簡單的說就是，活鎖和死鎖的主要差別是前者程序的狀态可以改變但是卻不能繼續執行。
29） 怎麼檢測一個線程是否擁有鎖？
我一直不知道我們竟然可以檢測一個線程是否擁有鎖，直到我參加了一次電話面試。在java.lang.Thread中有一個方法叫holdsLock()，它傳回true如果當且僅當目前線程擁有某個具體對象的鎖。
30) 你如何在Java中擷取線程堆棧？
對于不同的作業系統，有多種方法來獲得Java程序的線程堆棧。當你擷取線程堆棧時，JVM會把所有線程的狀态存到日志檔案或者輸出到控制台。在Windows你可以使用Ctrl + Break組合鍵來擷取線程堆棧，Linux下用kill -3指令。你也可以用jstack這個工具來擷取，它對線程id進行操作，你可以用jps這個工具找到id。
31) JVM中哪個參數是用來控制線程的棧堆棧小的
這個問題很簡單， -Xss參數用來控制線程的堆棧大小。你可以檢視JVM配置清單來了解這個參數的更多資訊。
32） Java中synchronized 和 ReentrantLock 有什麼不同？
Java在過去很長一段時間隻能通過synchronized關鍵字來實作互斥，它有一些缺點。比如你不能擴充鎖之外的方法或者塊邊界，嘗試擷取鎖時不能中途取消等。Java 5 通過Lock接口提供了更複雜的控制來解決這些問題。 ReentrantLock 類實作了 Lock，它擁有與 synchronized 相同的并發性和記憶體語義且它還具有可擴充性。
33） 有三個線程T1，T2，T3，怎麼確定它們按順序執行？
在多線程中有多種方法讓線程按特定順序執行，你可以用線程類的join()方法在一個線程中啟動另一個線程，另外一個線程完成該線程繼續執行。為了確定三個線程的順序你應該先啟動最後一個(T3調用T2，T2調用T1)，這樣T1就會先完成而T3最後完成。
34) Thread類中的yield方法有什麼作用？
Yield方法可以暫停目前正在執行的線程對象，讓其它有相同優先級的線程執行。它是一個靜态方法而且隻保證目前線程放棄CPU占用而不能保證使其它線程一定能占用CPU，執行yield()的線程有可能在進入到暫停狀态後馬上又被執行。
35） Java中ConcurrentHashMap的并發度是什麼？
ConcurrentHashMap把實際map劃分成若幹部分來實作它的可擴充性和線程安全。這種劃分是使用并發度獲得的，它是ConcurrentHashMap類構造函數的一個可選參數，預設值為16，這樣在多線程情況下就能避免争用。
36） Java中Semaphore是什麼？
Java中的Semaphore是一種新的同步類，它是一個計數信号。從概念上講，從概念上講，信号量維護了一個許可集合。如有必要，在許可可用前會阻塞每一個 acquire()，然後再擷取該許可。每個 release()添加一個許可，進而可能釋放一個正在阻塞的擷取者。但是，不使用實際的許可對象，Semaphore隻對可用許可的号碼進行計數，并采取相應的行動。
37）如果你送出任務時，線程池隊列已滿。會時發會生什麼？
這個問題問得很狡猾，許多程式員會認為該任務會阻塞直到線程池隊列有空位。事實上如果一個任務不能被排程執行那麼ThreadPoolExecutor’s submit()方法将會抛出一個RejectedExecutionException異常。
38) Java線程池中submit() 和 execute()方法有什麼差別？
兩個方法都可以向線程池送出任務，execute()方法的傳回類型是void，它定義在Executor接口中, 而submit()方法可以傳回持有計算結果的Future對象，它定義在ExecutorService接口中，它擴充了Executor接口，其它線程池類像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有這些方法。
39) 什麼是阻塞式方法？
阻塞式方法是指程式會一直等待該方法完成期間不做其他事情，ServerSocket的accept()方法就是一直等待用戶端連接配接。這裡的阻塞是指調用結果傳回之前，目前線程會被挂起，直到得到結果之後才會傳回。此外，還有異步和非阻塞式方法在任務完成前就傳回。
40) Swing是線程安全的嗎？ 為什麼？
你可以很肯定的給出回答，Swing不是線程安全的，但是你應該解釋這麼回答的原因即便面試官沒有問你為什麼。當我們說swing不是線程安全的常常提到它的元件，這些元件不能在多線程中進行修改，所有對GUI元件的更新都要在AWT線程中完成，而Swing提供了同步和異步兩種回調方法來進行更新