java面試題2020搶先看，夠全

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 程序員和多年經驗的高級開發者的問題。不管你是 一、二、三、四、五、六、七、八、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 methodsynchronized (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 byteb += 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.7private static final int DEFAULT_CAPACITY = 10;//from HashMap.java JDK 7static 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;    a=a^b;    printf("a=%d b=%d \n",a,b);    getchar();    return 0;}

//效果截圖以下：

分析下a和b發生交換的緣由：

根據以上代碼不可貴出如下表達式:

1. b=(a^b)^b=a^b^b=a2. 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提供了同步和異步兩種回調方法來進行更新

**41） Java中invokeAndWait 和 invokeLater有什麼區別？
**這兩個方法是Swing API 提供給Java開發者用來從當前線程而不是事件派發線程更新GUI組件用的。InvokeAndWait()同步更新GUI組件，好比一個進度條，一旦進度更新了，進度條也要作出相應改變。若是進度被多個線程跟蹤，那麼就調用invokeAndWait()方法請求事件派發線程對組件進行相應更新。而invokeLater()方法是異步調用更新組件的。

**42) Swing API中那些方法是線程安全的？
**這個問題又提到了swing和線程安全，雖然組件不是線程安全的可是有一些方法是能夠被多線程安全調用的，好比repaint(), revalidate()。JTextComponent的setText()方法和JTextArea的insert() 和 append() 方法也是線程安全的。

**43) 如何在Java中建立Immutable對象？
**這個問題看起來和多線程沒什麼關係， 但不變性有助於簡化已經很複雜的併發程序。Immutable對象能夠在沒有同步的狀況下共享，下降了對該對象進行併發訪問時的同步化開銷。但是Java沒有@Immutable這個註解符，要建立不可變類，要實現下面幾個步驟：經過構造方法初始化全部成員、對變量不要提供setter方法、將全部的成員聲明爲私有的，這樣就不容許直接訪問這些成員、在getter方法中，不要直接返回對象自己，而是克隆對象，並返回對象的拷貝。

**44） Java中的ReadWriteLock是什麼？
**通常而言，讀寫鎖是用來提高併發程序性能的鎖分離技術的成果。Java中的ReadWriteLock是Java 5 中新增的一個接口，一個ReadWriteLock維護一對關聯的鎖，一個用於只讀操做一個用於寫。在沒有寫線程的狀況下一個讀鎖可能會同時被多個讀線程持有。寫鎖是獨佔的，你能夠使用JDK中的ReentrantReadWriteLock來實現這個規則，它最多支持65535個寫鎖和65535個讀鎖。

**45) 多線程中的忙循環是什麼?
**忙循環就是程序員用循環讓一個線程等待，不像傳統方法wait(), sleep() 或 yield() 它們都放棄了CPU控制，而忙循環不會放棄CPU，它就是在運行一個空循環。這麼作的目的是爲了保留CPU緩存，在多核系統中，一個等待線程醒來的時候可能會在另外一個內核運行，這樣會重建緩存。爲了不重建緩存和減小等待重建的時間就能夠使用它了。

**46）volatile 變量和 atomic 變量有什麼不一樣？
**這是個有趣的問題。首先，volatile 變量和 atomic 變量看起來很像，但功能卻不同。Volatile變量能夠確保先行關係，即寫操做會發生在後續的讀操做以前, 但它並不能保證原子性。例如用volatile修飾count變量那麼 count++ 操做就不是原子性的。而AtomicInteger類提供的atomic方法可讓這種操做具備原子性如getAndIncrement()方法會原子性的進行增量操做把當前值加一，其它數據類型和引用變量也能夠進行類似操做。

**47) 若是同步塊內的線程拋出異常會發生什麼？
**這個問題坑了不少Java程序員，若你能想到鎖是否釋放這條線索來回答還有點但願答對。不管你的同步塊是正常仍是異常退出的，裏面的線程都會釋放鎖，因此對比鎖接口我更喜歡同步塊，由於它不用我花費精力去釋放鎖，該功能能夠在finally block裏釋放鎖實現。

**48） 單例模式的雙檢鎖是什麼？
**這個問題在Java面試中常常被問到，可是面試官對回答此問題的滿意度僅爲50%。一半的人寫不出雙檢鎖還有一半的人說不出它的隱患和Java1.5是如何對它修正的。它實際上是一個用來建立線程安全的單例的老方法，當單例實例第一次被建立時它試圖用單個鎖進行性能優化，可是因爲太過於複雜在JDK1.4中它是失敗的，我我的也不喜歡它。不管如何，即使你也不喜歡它可是仍是要了解一下，由於它常常被問到。

**49） 如何在Java中建立線程安全的Singleton？
**這是上面那個問題的後續，若是你不喜歡雙檢鎖而面試官問了建立Singleton類的替代方法，你能夠利用JVM的類加載和靜態變量初始化特徵來建立Singleton實例，或者是利用枚舉類型來建立Singleton，我很喜歡用這種方法。

**50) 寫出3條你遵循的多線程最佳實踐 **這種問題我最喜歡了，我相信你在寫併發代碼來提高性能的時候也會遵循某些最佳實踐。如下三條最佳實踐我以爲大多數Java程序員都應該遵循： 給你的線程起個有意義的名字。 這樣能夠方便找bug或追蹤。OrderProcessor, QuoteProcessor or TradeProcessor 這種名字比 Thread-1. Thread-2 and Thread-3 好多了，給線程起一個和它要完成的任務相關的名字，全部的主要框架甚至JDK都遵循這個最佳實踐。 避免鎖定和縮小同步的範圍 鎖花費的代價高昂且上下文切換更耗費時間空間，試試最低限度的使用同步和鎖，縮小臨界區。所以相對於同步方法我更喜歡同步塊，它給我擁有對鎖的絕對控制權。 多用同步類少用wait 和 notify 首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 這些同步類簡化了編碼操做，而用wait和notify很難實現對複雜控制流的控制。其次，這些類是由最好的企業編寫和維護在後續的JDK中它們還會不斷優化和完善，使用這些更高等級的同步工具你的程序能夠不費吹灰之力得到優化。 多用併發集合少用同步集合 這是另一個容易遵循且受益巨大的最佳實踐，併發集合比同步集合的可擴展性更好，因此在併發編程時使用併發集合效果更好。若是下一次你須要用到map，你應該首先想到用ConcurrentHashMap。