Java笔试题解答和部分面试题
?
銀行類的問題
問題一：在多線程環境中使用HashMap會有什么問題？在什么情況下使用get()方法會產生無限循環？
HashMap本身沒有什么問題，有沒有問題取決于你是如何使用它的。比如，你在一個線程里初始化了一個HashMap然后在多個其他線程里對其進行讀取，這肯定沒有任何問題。有個例子就是使用HashMap來存儲系統配置項。當有多于一個線程對HashMap進行修改操作的時候才會真正產生問題，比如增加、刪除、更新鍵值對的時候。因為put()操作可以造成重新分配存儲大小（re-sizeing）的動作，因此有可能造成無限循環的發生，所以這時需要使用Hashtable或者ConcurrentHashMap，而后者更優。
問題二：不重寫Bean的hashCode()方法是否會對性能帶來影響？
這個問題非常好，每個人可能都會有自己的體會。按照我掌握的知識來說，如果一個計算hash的方法寫得不好，直接的影響是，當向HashMap中添加元素的時候會更頻繁地造成沖突，因此最終增加了耗時。但是自從Java?8開始，這種影響不再像前幾個版本那樣顯著了，因為當沖突的發生超出了一定的限度之后，鏈表類的實現將會被替換成二叉樹（binary?tree）實現，這時你仍可以得到O(logN)的開銷，優于鏈表類的O(n)。
問題三：對于一個不可修改的類，它的每個對象是不是都必須聲明成final的？
不盡然，因為你可以通過將成員聲明成非final且private，并且不要在除了構造函數的其他地方來修改它。不要為它們提供setter方法，同時不會通過任何函數泄露出對此成員的引用。需要記住的是，把對象聲明成final僅僅保證了它不會被重新賦上另外一個值，你仍然可以通過此引用來修改引用對象的屬性。這一點是關鍵，面試官通常喜歡聽到你強調這一點。
問題四：String的substring()方法內部是如何實現的？
又一個Java面試的好問題，你應該答出“substring方法通過原字符串創建了一個新的對象”，否則你的回答肯定是不能令人滿意的。這個問題也經常被拿來測試應聘者對于substring()可能帶來的內存泄漏風險是否有所了解。直到Java?1.7版本之前，substring會保存一份原字符串的字符數組的引用，這意味著，如果你從1GB大小的字符串里截取了5個字符，而這5個字符也會阻止那1GB內存被回收，因為這個引用是強引用。
到了Java?1.7，這個問題被解決了，原字符串的字符數組已經不再被引用，但是這個改變也使得substring()創建字符串的操作更加耗時，以前的開銷是O(1)，現在最壞情況是O(n)。
問題五：能否寫一個單例模式，并且保證實例的唯一性？
這算是Java一個比較核心的問題了，面試官期望你能知道在寫單例模式時應該對實例的初始化與否進行雙重檢查。記住對實例的聲明使用Volatile關鍵字，以保證單例模式是線程安全的。下面是一段示例，展示了如何用一種線程安全的方式實現了單例模式：
public class Singleton {private static volatile Singleton _instance; /** * Double checked locking code on Singleton * @return Singelton instance */ public static Singleton getInstance() { if (_instance == null) { synchronized (Singleton.class) { if (_instance == null) { _instance = new Singleton(); } } } return _instance; } }問題六：你在寫存儲過程或者在Java里調用存儲過程的時候如何來處理錯誤情況？
這是個很棘手的Java面試題，答案也并不固定。我的答案是，寫存儲過程的時候一旦有操作失敗，則一定要返回錯誤碼。但是在調用存儲過程的時候出錯的話捕捉SQLException卻是唯一能做的。
問題七：Executor.submit()和Executor.execute()這兩個方法有什么區別？
此問題來自另外一篇文章，《15個最流行的java多線程面試問題》，現在對熟練掌握并發技能的開發者的需求越來越大，因此這個問題也越來越引起大家的重視。答案是：前者返回一個Future對象，可以通過這個對象來獲得工作線程執行的結果。
當我們考察異常處理的時候，又會發現另外一個不同。當你使用execute提交的任務拋出異常時，此異常將會交由未捕捉異常處理過程來處理（uncaught?exception?handler），當你沒有顯式指定一個異常處理器的話，默認情況下僅僅會通過System.err打印出錯誤堆棧。當你用submit來提交一個任務的時候，這個任務一旦拋出異常（無論是否是運行時異常），那這個異常是任務返回對象的一部分。對這樣一種情形，當你調用Future.get()方法的時候，這個方法會重新拋出這個異常，并且會使用ExecutionException進行包裝。
問題八：工廠模式和抽象工廠模式有何不同？
抽象工廠模式提供了多一級的抽象。不同的工廠類都繼承了同一個抽象工廠方法，但是卻根據工廠的類別創建不同的對象。例如，AutomobileFactory,?UserFactory,?RoleFactory都繼承了AbstractFactory，但是每個工廠類創建自己對應類型的對象。下面是工廠模式和抽象工廠模式對應的UML圖。
問題九：什么是單例模式？創建單例對象的時候是將整個方法都標記為synchronized好還是僅僅把創建的的語句標記為synchronized好？
在Java中，單例類是指那些在整個Java程序中只存在一份實例的類，例如java.lang.Runtime就是一個單例類。在Java?4版本及以前創建單例會有些麻煩，但是自從Java?5引入了Enum類型之后，事情就變得簡單了。可以去看看我的關于如何使用Enum來創建單例類的文章，同時再看看問題五來看看如何在創建單例類的時候進行雙重檢查。
問題十：能否寫一段用Java?4或5來遍歷一個HashMap的代碼？
事實上，用Java可以有四種方式來遍歷任何一個Map，一種是使用keySet()方法獲取所有的鍵，然后遍歷這些鍵，再依次通過get()方法來獲取對應的值。第二種方法可以使用entrySet()來獲取鍵值對的集合，然后使用for?each語句來遍歷這個集合，遍歷的時候獲得的每個鍵值對已經包含了鍵和值。這種算是一種更優的方式，因為每輪遍歷的時候同時獲得了key和value，無需再調用get()方法，get()方法在那種如果bucket位置有一個巨大的鏈表的時候的性能開銷是O(n)。第三種方法是獲取entrySet之后用iterator依次獲取每個鍵值對。第四種方法是獲得key?set之后用iterator依次獲取每個key，然后再根據key來調用get方法。
問題十一：你在什么時候會重寫hashCode()和equals()方法？
當你需要根據業務邏輯來進行相等性判斷、而不是根據對象相等性來判斷的時候你就需要重寫這兩個函數了。例如，兩個Employee對象相等的依據是它們擁有相同的emp_id，盡管它們有可能是兩個不同的Object對象，并且分別在不同的地方被創建。同時，如果你準備把它們當作HashMap中的key來使用的話，你也必須重寫這兩個方法。現在，作為Java中equals-hashcode的一個約定，當你重寫equals的時候必須也重寫hashcode，否則你會打破諸如Set,?Map等集合賴以正常工作的約定。你可以看看我的另外一篇博文來理解這兩個方法之間的微妙區別與聯系。
問題十二：如果不重寫hashCode方法會有什么問題？
如果不重寫equals方法的話，equals和hashCode之間的約定就會被打破：當通過equals方法返回相等的兩個對象，他們的hashCode也必須一樣。如果不重寫hashCode方法的話，即使是使用equals方法返回值為true的兩個對象，當它們插入同一個map的時候，因為hashCode返回不同所以仍然會被插入到兩個不同的位置。這樣就打破了HashMap的本來目的，因為Map本身不允許存進去兩個key相同的值。當使用put方法插入一個的時候，HashMap會先計算對象的hashcode，然后根據它來找到存儲位置(bucket)，然后遍歷此存儲位置上所有的Map.Entry對象來查看是否與待插入對象相同。如果沒有提供hashCode的話，這些就都做不到了。
問題十三：我們要同步整個getInstance()方法，還是只同步getInstance()方法中的關鍵部分？
答案是：僅僅同步關鍵部分（Critical?Section）。這是因為，如果我們同步整個方法的話，每次有線程調用getInstance()方法的時候都會等待其他線程調用完成才行，即使在此方法中并沒有執行對象的創建操作。換句話說，我們只需要同步那些創建對象的代碼，而創建對象的代碼只會執行一次。一旦對象創建完成之后，根本沒有必要再對方法進行同步保護了。事實上，從性能上來說，對方法進行同步保護這種編碼方法非常要命，因為它會使性能降低10到20倍。下面是單例模式的UML圖。
再補充一下，創建線程安全的單例對象有多種方法，你也可以順便提一下。
問題十四：HashMap，在調用get()方法的時候equals()和hashCode()方法都起了什么樣的作用？
這個問題算是對問題十二的補充，應聘者應該知道的是，一旦你提到了hashCode()方法，人們很可能要問HashMap是如何使用這個函數的。當你向HashMap插入一個key的時候，首先，這個對象的hashCode()方法會被調用，調用結果用來計算將要存儲的位置(bucket)。
因為某個位置上可能以鏈表的方式已經包含了多個Map.Entry對象，所以HashMap會使用equals()方法來將此對象與所有這些Map.Entry所包含的key進行對比，以確定此key對象是否已經存在。
問題十五：在Java中如何避免死鎖？
你可以通過打破互相等待的局面來避免死鎖。為了達到這一點，你需要在代碼中合理地安排獲取和釋放鎖的順序。如果獲得鎖的順序是固定的，并且獲得的順序和釋放的順序剛好相反的話，就不會產生出現死鎖的條件了。
問題十六：創建字符串對象的時候，使用字面值和使用new?String()構造器這兩種方式有什么不同？
當我們使用new?String構造器來創建字符串的時候，字符串的值會在堆中創建，而不會加入JVM的字符串池中。相反，使用字面值創建的String對象會被放入堆的PermGen段中。例如：
String str=new String(“Test”);這句代碼創建的對象str不會放入字符串池中，我們需要顯式調用String.intern()方法來將它放入字符串池中。僅僅當你使用字面值創建字符串時，Java才會自動將它放入字符串池中，比如：String?s=”Test”。順便提一下，這里有個容易被忽視的地方，當我們將參數“Test”傳入構造器的時候，這個參數是個字面值，因此它也會在字符串池中保存另外一份。想了解更多關于字面值字符串和字符串對象之間的差別，請看這篇文章。
下圖很好地解釋了這種差異。
問題十七：什么是不可修改對象(Immutable?Object)？你能否寫一個例子？
不可修改對象是那些一旦被創建就不能修改的對象。對這種對象的任何改動的后果都是會創建一個新的對象，而不是在原對象本身做修改。例如Java中的String類就是不可修改的。大多數這樣的類通常都是final類型的，因為這樣可以避免自己被繼承繼而被覆蓋方法，在覆蓋的方法里，不可修改的特性就難以得到保證了。你通常也可以通過將類的成員設置成private但是非final的來獲得同樣的效果。
另外，你同樣要保證你的類不要通過任何方法暴露成員，特別是那些可修改類型的成員。同樣地，當你的方法接收客戶類傳入的可修改對象的話，你應該使用一個復制的對象來防止客戶代碼來修改這個剛傳入的可修改類。比如，傳入java.util.Date對象的話，你應該自己使用clone()方法來獲得一個副本。
當你通過類函數返回一個可修改對象的時候，你也要采取類似的防護措施，返回一個類成功的副本，防止客戶代碼通過此引用修改了成員對象的屬性。千萬不要直接把你的可修改成員直接返回給客戶代碼。
問題十八：如何在不使用任何分析工具的情況下用最簡單的方式計算某個方法的執行所花費的時間？
在執行此方法之前和之后獲取一個系統時間，取這兩個時間的差值，即可得到此方法所花費的時間。
需要注意的是，如果執行此方法花費的時間非常短，那么得到的時間值有可能是0ms。這時你可以在一個計算量比較大的方法上試一下效果。
long start=System.currentTimeMillis();method();long end=System.currentTimeMillis();System.out.println("Time taken for execution is "+(end-start));問題十九：當你要把某個類作為HashMap的key使用的話，你需要重寫這個類的哪兩個方法？
為了使類可以在HashMap或Hashtable中作為key使用，必須要實現這個類自己的equals()和hashCode()方法。具體請參考問題十四。
問題二十：你如何阻止客戶代碼直接初始化你的類的構造方法？例如，你有一個名為Cache的接口和兩個具體的實現類MemoryCache和DiskCache，你如何保證這兩個類禁止客戶代碼用new關鍵字來獲取它們的實例？
我把這最后一個問題留給你做練習吧，你可以在我給出答案之前好好思索一下。我確信你能夠找到正確的方法的，因為這是將類的實現掌控在自己手中的一個重要的方法，同時也能為以后的維護提供巨大的好處。
?
?
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 方法的代碼：
參見?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）什么是線程局部變量？(答案)
線程局部變量是局限于線程內部的變量，屬于線程自身所有，不在多個線程間共享。Java 提供?ThreadLocal?類來支持線程局部變量，是一種實現線程安全的方式。但是在管理環境下（如 web 服務器）使用線程局部變量的時候要特別小心，在這種情況下，工作線程的生命周期比任何應用變量的生命周期都要長。任何線程局部變量一旦在工作完成后沒有釋放，Java 應用就存在內存泄露的風險。
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 類型？
這個問題你來回答
20）我們能將 int 強制轉換為 byte 類型的變量嗎？如果該值大于 byte 類型的范圍，將會出現什么現象？
是的，我們可以做強制轉換，但是 Java 中 int 是 32 位的，而 byte 是 8 位的，所以，如果強制轉化是，int 類型的高 24 位將會被丟棄，byte 類型的范圍是從 -128 到 128。
21）存在兩個類，B 繼承 A，C 繼承 B，我們能將 B 轉換為 C 么？如 C = (C) B；(answer答案)
22）哪個類包含 clone 方法？是 Cloneable 還是 Object？(答案)
java.lang.Cloneable 是一個標示性接口，不包含任何方法，clone 方法在 object 類中定義。并且需要知道 clone() 方法是一個本地方法，這意味著它是由 c 或 c++ 或 其他本地語言實現的。
23）Java 中 ++ 操作符是線程安全的嗎？(答案)
23）不是線程安全的操作。它涉及到多個指令，如讀取變量值，增加，然后存儲回內存，這個過程可能會出現多個線程交差。
24）a = a + b 與 a += b 的區別(答案)
+= 隱式的將加操作的結果類型強制轉換為持有結果的類型。如果兩這個整型相加，如 byte、short 或者 int，首先會將它們提升到 int 類型，然后在執行加法操作。如果加法操作的結果比 a 的最大值要大，則 a+b 會出現編譯錯誤，但是 a += b 沒問題，如下：
byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok
（譯者注：這個地方應該表述的有誤，其實無論 a+b 的值為多少，編譯器都會報錯，因為 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）？(answer答案)
Java 中的 String 不可變是因為 Java 的設計者認為字符串使用非常頻繁，將字符串設置為不可變可以允許多個客戶端之間共享相同的字符串。更詳細的內容參見答案。
29）我們能在 Switch 中使用 String 嗎？(answer答案)
從 Java 7 開始，我們可以在 switch case 中使用字符串，但這僅僅是一個語法糖。內部實現在 switch 中使用字符串的 hash code。
30）Java 中的構造器鏈是什么？(answer答案)
當你從一個構造器中調用另一個構造器，就是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的區別？(答案)
雖然 WeakReference 與 SoftReference 都有利于提高 GC 和 內存的效率，但是 WeakReference ，一旦失去最后一個強引用，就會被 GC 回收，而軟引用雖然不能阻止被回收，但是可以延遲到 JVM 內存不足的時候。
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.gc()，但是沒有辦法保證 GC 的執行。
42）怎么獲取 Java 程序使用的內存？堆使用的百分比？
可以通過 java.lang.Runtime 類中與內存相關方法來獲取剩余的內存，總內存及最大堆內存。通過這些方法你也可以獲取到堆使用的百分比及堆內存的剩余空間。Runtime.freeMemory() 方法返回剩余空間的字節數，Runtime.totalMemory() 方法總內存的字節數，Runtime.maxMemory() 返回最大內存的字節數。
43）Java 中堆和棧有什么區別？(答案)
JVM 中堆和棧屬于不同的內存區域，使用目的也不同。棧常用于保存方法幀和局部變量，而對象總是在堆上分配。棧通常都比堆小，也不會在多個線程之間共享，而堆被整個 JVM 的所有線程共享。
關于內存的的面試問題和答案
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 修飾變量，意味著該變量的值在初始化后不能被改變。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 1661）有沒有可能兩個不相等的對象有有相同的 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 語句。
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 中，怎么在格式化的日期中顯示時區？(答案)
85）Java 中 java.util.Date 與 java.sql.Date 有什么區別？(答案)
86）Java 中，如何計算兩個日期之間的差距？(程序)
87）Java 中，如何將字符串 YYYYMMDD 轉換為日期？(答案)
單元測試 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）在沒有使用臨時變量的情況如何交換兩個整數變量的值？(解決方案)
關于 OOP 和設計模式的面試題
這部分包含 Java 面試過程中關于 SOLID 的設計原則，OOP 基礎，如類，對象，接口，繼承，多態，封裝，抽象以及更高級的一些概念，如組合、聚合及關聯。也包含了 GOF 設計模式的問題。
103）接口是什么？為什么要使用接口而不是直接使用具體類？
接口用于定義 API。它定義了類必須得遵循的規則。同時，它提供了一種抽象，因為客戶端只使用接口，這樣可以有多重實現，如 List 接口，你可以使用可隨機訪問的 ArrayList，也可以使用方便插入和刪除的 LinkedList。接口中不允許寫代碼，以此來保證抽象，但是 Java 8 中你可以在接口聲明靜態的默認方法，這種方法是具體的。
104）Java 中，抽象類與接口之間有什么不同？(答案)
Java 中，抽象類和接口有很多不同之處，但是最重要的一個是 Java 中限制一個類只能繼承一個類，但是可以實現多個接口。抽象類可以很好的定義一個家族類的默認行為，而接口能更好的定義類型，有助于后面實現多態機制。關于這個問題的討論請查看答案。
105）除了單例模式，你在生產環境中還用過什么設計模式？
這需要根據你的經驗來回答。一般情況下，你可以說依賴注入，工廠模式，裝飾模式或者觀察者模式，隨意選擇你使用過的一種即可。不過你要準備回答接下的基于你選擇的模式的問題。
106）你能解釋一下里氏替換原則嗎?(答案)
107) 什么情況下會違反迪米特法則？為什么會有這個問題？(答案)
迪米特法則建議“只和朋友說話，不要陌生人說話”，以此來減少類之間的耦合。
108）適配器模式是什么？什么時候使用？
適配器模式提供對接口的轉換。如果你的客戶端使用某些接口，但是你有另外一些接口，你就可以寫一個適配去來連接這些接口。
109）什么是“依賴注入”和“控制反轉”？為什么有人使用？(答案)
110）抽象類是什么？它與接口有什么區別？你為什么要使用過抽象類？(答案)
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 工具更多的不同之處請參見答案。
?
筆試類1. 看不見的空格？
下面的輸出會正常嗎？
package basic;public class IntegerTest {public static void main(String[] args) {System.out.println(Integer.parseInt("1"));System.out.println(Integer.parseInt("2"));} }
解析：將上面代碼復制下（不要自己手敲）在自己的環境里運行看看，是不是輸出下面錯誤來了：
1
Exception in thread “main” java.lang.NumberFormatException: For input string: “2”
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at basic.IntegerTest.main(IntegerTest.java:7)
竟然說第二條語句有問題，表面上完全看不出來任何問題是不是！
實際上這里的錯誤原因涉及到一個概念 —?零寬度空格，可能有人接觸過，但相信更多的人甚至都沒聽過，什么是零寬度空格？它實際上是一個Unicode字符，是一個空格，關鍵是它沒有寬度，因此我們一般肉眼看不到。但可以在vim下看到，上面的第二條語句中的2前面就有一個零寬度空格，放到vim中打開后你會發現是下面這樣的語句：
Unicode規范中定義，每一個文件的最前面分別加入一個表示編碼順序的字符，這個字符的名字叫做”零寬度非換行空格“（ZEROWIDTHNO-BREAKSPACE），用FEFF表示。這正好是兩個字節，而且FF比FE大1。因此下面的語句會輸出65279，剛好是FEFF。
?
2. 類靜態成員初始化
下面的程序能編譯通過么？如果通過，說結果并解釋，不能編譯，說錯誤原因。
class A {public static int X;static { X = B.Y + 1;} } public class B {public static int Y = A.X + 1;static {}public static void main(String[] args) {System.out.println("X = "+A.X+", Y = "+B.Y);} }
解析：這個程序能正確運行，類的運行過程如下：
首先加載主類B，初始化靜態成員Y，發現需要類A的信息，于是加載類A，初始化靜態成員X，也用到B類信息，由于此時B類的Y還未成功加載因此這里是默認值0，從而得到A類的X為1，然后返回到B類，得到Y為2。
?
3. 裝箱拆箱的實際過程
關于自動裝箱，相信大部分人都明白是怎么一回事，但真的完全明白了嘛？
先看下面的代碼：
誰都知道當然打印true了。現在加一句試試：
還是true嗎？No，這次輸出成了false。WHY？難道s1和s2引用的不是同一個對象嗎？有這些疑問的說明你對自動裝箱拆箱的過程還不是非常清楚，實際上上面的代碼可以翻譯為下面的代碼（實際執行過程，要掌握）：
哦，原來如此，這下明白了，因此我們在使用自動裝箱的時候小心點為妙。
?
4. 你自以為是的異常
先來兩句代碼：
NullTest myNullTest = null; System.out.println(myNullTest.getInt());
相信很多人看到這段代碼時，都會自以為是的說：NullPointerException。果真如此嗎？你還沒看到NullTest 這個類是如何定義的呢。現在看看這個類的定義：
發現getInt()方法體沒有任何類變量和類方法的使用，因此這里會正常輸出1.
記住：類變量和類方法的使用，僅僅依賴引用的類型。即使引用為null，仍然可以調用。從良好實踐的角度來看，明智的做法是使用NullTest.getInt()來代替myNullTest.getInt()，但誰不不能保證不會碰到這樣的代碼，因此還是小心為妙。
?
5. 變長參數和數組，如何變通？
變長參數特性帶來了一個強大的概念，可以幫助開發者簡化代碼。不過變長參數的背后是什么呢？Basically，就是一個數組。
public void calc(int... myInts) {} calc(1, 2, 3);
編譯器會將前面的代碼翻譯成類似這樣：
不過這里有兩點需要注意：
- 當心空調用語句，這相當于傳遞了一個null作為參數。
calc();
等價于
int[] ints = null;
calc(ints);
- 當然，下面的代碼會導致編譯錯誤，因為兩條語句是等價的：
public void m1(int[] myInts) { … }?
public void m1(int… myInts) { … }
A start() ? ? ? B run() ? ? ? C exit() ? ? ? D getPriority()
答案：ABD
解析：看Java API docs吧：http://docs.oracle.com/javase/7/docs/api/，exit()是System類的方法，如System.exit(0)。2. 下面關于java.lang.Exception類的說法正確的是（）
A 繼承自Throwable ? ?? B Serialable ? ?? CD 不記得，反正不正確
答案：A
解析：Java異常的基類為java.lang.Throwable，java.lang.Error和java.lang.Exception繼承 Throwable，RuntimeException和其它的Exception等繼承Exception，具體的RuntimeException繼承RuntimeException。擴展：錯誤和異常的區別(Error vs Exception)?
1)?java.lang.Error: Throwable的子類，用于標記嚴重錯誤。合理的應用程序不應該去try/catch這種錯誤。絕大多數的錯誤都是非正常的，就根本不該出現的。
java.lang.Exception: Throwable的子類，用于指示一種合理的程序想去catch的條件。即它僅僅是一種程序運行條件，而非嚴重錯誤，并且鼓勵用戶程序去catch它。
2)? Error和RuntimeException 及其子類都是未檢查的異常（unchecked exceptions），而所有其他的Exception類都是檢查了的異常（checked exceptions）.
checked exceptions:?通常是從一個可以恢復的程序中拋出來的，并且最好能夠從這種異常中使用程序恢復。比如FileNotFoundException, ParseException等。檢查了的異常發生在編譯階段，必須要使用try…catch（或者throws）否則編譯不通過。
unchecked exceptions:?通常是如果一切正常的話本不該發生的異常，但是的確發生了。發生在運行期，具有不確定性，主要是由于程序的邏輯問題所引起的。比如ArrayIndexOutOfBoundException, ClassCastException等。從語言本身的角度講，程序不該去catch這類異常，雖然能夠從諸如RuntimeException這樣的異常中catch并恢復，但是并不鼓勵終端程序員這么做，因為完全沒要必要。因為這類錯誤本身就是bug，應該被修復，出現此類錯誤時程序就應該立即停止執行。 因此，面對Errors和unchecked exceptions應該讓程序自動終止執行，程序員不該做諸如try/catch這樣的事情，而是應該查明原因，修改代碼邏輯。
RuntimeException：RuntimeException體系包括錯誤的類型轉換、數組越界訪問和試圖訪問空指針等等。
處理RuntimeException的原則是：如果出現 RuntimeException，那么一定是程序員的錯誤。例如，可以通過檢查數組下標和數組邊界來避免數組越界訪問異常。其他（IOException等等）checked異常一般是外部錯誤，例如試圖從文件尾后讀取數據等，這并不是程序本身的錯誤，而是在應用環境中出現的外部錯誤。?
?
3. 下面程序的運行結果是（）
String str1 = "hello"; String str2 = "he" + new String("llo"); System.err.println(str1 == str2);答案：false
解析：因為str2中的llo是新申請的內存塊，而==判斷的是對象的地址而非值，所以不一樣。如果是String str2 = str1，那么就是true了。
?
4.?下列說法正確的有（）
A． class中的constructor不可省略
B． constructor必須與class同名，但方法不能與class同名
C． constructor在一個對象被new時執行
D．一個class只能定義一個constructor
答案：C?
解析：這里可能會有誤區，其實普通的類方法是可以和類名同名的，和構造方法唯一的區分就是，構造方法沒有返回值。
?
5. 具體選項不記得，但用到的知識如下：
String []a = new String[10];
則：a[0]~a[9] = null
a.length = 10
如果是int []a = new int[10];
則：a[0]~a[9] = 0
a.length = 10
?
6. 下面程序的運行結果：（）
public static void main(String args[]) {Thread t = new Thread() {public void run() {pong();}};t.run();System.out.print("ping");}static void pong() {System.out.print("pong");}A pingpong ? ? ?? B pongping ? ? ? C pingpong和pongping都有可能 ? ? ? D 都不輸出
答案：B
解析：這里考的是Thread類中start()和run()方法的區別了。start()用來啟動一個線程，當調用start方法后，系統才會開啟一個新的線程，進而調用run()方法來執行任務，而單獨的調用run()就跟調用普通方法是一樣的，已經失去線程的特性了。因此在啟動一個線程的時候一定要使用start()而不是run()。
?
7. 下列屬于關系型數據庫的是（）
A. Oracle ? ?B MySql ? ?C IMS ? ? D MongoDB
答案：AB
解答：IMS（Information Management System?）數據庫是IBM公司開發的兩種數據庫類型之一;?
一種是關系數據庫，典型代表產品：DB2；
另一種則是層次數據庫，代表產品：IMS層次數據庫。
非關系型數據庫有MongoDB、memcachedb、Redis等。
?
8. GC線程是否為守護線程？（）
答案：是
解析：線程分為守護線程和非守護線程（即用戶線程）。
只要當前JVM實例中尚存在任何一個非守護線程沒有結束，守護線程就全部工作；只有當最后一個非守護線程結束時，守護線程隨著JVM一同結束工作。 守護線程最典型的應用就是 GC (垃圾回收器)?
9. volatile關鍵字是否能保證線程安全？（）
答案：不能
解析：volatile關鍵字用在多線程同步中，可保證讀取的可見性，JVM只是保證從主內存加載到線程工作內存的值是最新的讀取值，而非cache中。但多個線程對
volatile的寫操作，無法保證線程安全。例如假如線程1，線程2 在進行read,load 操作中，發現主內存中count的值都是5，那么都會加載這個最新的值，在線程1堆count進行修改之后，會write到主內存中，主內存中的count變量就會變為6；線程2由于已經進行read,load操作，在進行運算之后，也會更新主內存count的變量值為6；導致兩個線程及時用volatile關鍵字修改之后，還是會存在并發的情況。
?
10. 下列說法正確的是（）
A LinkedList繼承自List
B AbstractSet繼承自Set
C HashSet繼承自AbstractSet
D WeakMap繼承自HashMap
答案：AC
解析：下面是一張下載的Java中的集合類型的繼承關系圖，一目了然。
?
11. 存在使i + 1 < i的數嗎（）
答案：存在
解析：如果i為int型，那么當i為int能表示的最大整數時，i+1就溢出變成負數了，此時不就<i了嗎。
擴展：存在使i > j || i <= j不成立的數嗎（）
答案：存在
解析：比如Double.NaN或Float.NaN，感謝@BuilderQiu網友指出。
?
12. 0.6332的數據類型是（）
A float ? ? B double ? ? C Float ? ?? D Double
答案：B
解析：默認為double型，如果為float型需要加上f顯示說明，即0.6332f
?
13. 下面哪個流類屬于面向字符的輸入流(? )
A??BufferedWriter?????????? B??FileInputStream??? ? ? ??C??ObjectInputStream????????? D? InputStreamReader
?答案：D
?解析：Java的IO操作中有面向字節(Byte)和面向字符(Character)兩種方式。
面向字節的操作為以8位為單位對二進制的數據進行操作，對數據不進行轉換，這些類都是InputStream和OutputStream的子類。
面向字符的操作為以字符為單位對數據進行操作，在讀的時候將二進制數據轉為字符，在寫的時候將字符轉為二進制數據，這些類都是Reader和Writer的子類。
總結：以InputStream（輸入）/OutputStream（輸出）為后綴的是字節流；
????????? 以Reader（輸入）/Writer（輸出）為后綴的是字符流。
擴展：Java流類圖結構，一目了然，解決大部分選擇題：
?
14. Java接口的修飾符可以為（）
A private ? ? B protected ??? C final ? ? ? D abstract
答案：CD
解析：接口很重要，為了說明情況，這里稍微啰嗦點：
（1）接口用于描述系統對外提供的所有服務,因此接口中的成員常量和方法都必須是公開(public)類型的,確保外部使用者能訪問它們；
（2）接口僅僅描述系統能做什么,但不指明如何去做,所以接口中的方法都是抽象(abstract)方法；
（3）接口不涉及和任何具體實例相關的細節,因此接口沒有構造方法,不能被實例化,沒有實例變量，只有靜態（static）變量；
（4）接口的中的變量是所有實現類共有的，既然共有，肯定是不變的東西，因為變化的東西也不能夠算共有。所以變量是不可變(final)類型，也就是常量了。
（5）?接口中不可以定義變量？如果接口可以定義變量，但是接口中的方法又都是抽象的，在接口中無法通過行為來修改屬性。有的人會說了，沒有關系，可以通過 實現接口的對象的行為來修改接口中的屬性。這當然沒有問題，但是考慮這樣的情況。如果接口 A 中有一個public 訪問權限的靜態變量 a。按照 Java 的語義，我們可以不通過實現接口的對象來訪問變量 a，通過 A.a = xxx; 就可以改變接口中的變量 a 的值了。正如抽象類中是可以這樣做的，那么實現接口 A 的所有對象也都會自動擁有這一改變后的 a 的值了，也就是說一個地方改變了 a，所有這些對象中 a 的值也都跟著變了。這和抽象類有什么區別呢，怎么體現接口更高的抽象級別呢，怎么體現接口提供的統一的協議呢，那還要接口這種抽象來做什么呢？所以接口中 不能出現變量，如果有變量，就和接口提供的統一的抽象這種思想是抵觸的。所以接口中的屬性必然是常量，只能讀不能改，這樣才能為實現接口的對象提供一個統 一的屬性。
通俗的講，你認為是要變化的東西，就放在你自己的實現中，不能放在接口中去，接口只是對一類事物的屬性和行為更高層次的抽象。對修改關閉，對擴展（不同的實現 implements）開放，接口是對開閉原則的一種體現。
所以：
接口的方法默認是public abstract；
接口中不可以定義變量即只能定義常量(加上final修飾就會變成常量)。所以接口的屬性默認是public static final 常量，且必須賦初值。
注意：final和abstract不能同時出現。
?
15. 不通過構造函數也能創建對象嗎（）
A 是 ? ? B 否
答案：A
解析：Java創建對象的幾種方式（重要）：
(1) 用new語句創建對象，這是最常見的創建對象的方法。
(2) 運用反射手段,調用java.lang.Class或者java.lang.reflect.Constructor類的newInstance()實例方法。
(3) 調用對象的clone()方法。
(4) 運用反序列化手段，調用java.io.ObjectInputStream對象的 readObject()方法。
(1)和(2)都會明確的顯式的調用構造函數 ；(3)是在內存上對已有對象的影印，所以不會調用構造函數 ；(4)是從文件中還原類的對象，也不會調用構造函數。
?
16. ArrayList list = new ArrayList(20);中的list擴充幾次（）
A 0 ? ? B 1 ? ? C 2 ? ?? D 3
答案：A
解析：這里有點迷惑人，大家都知道默認ArrayList的長度是10個，所以如果你要往list里添加20個元素肯定要擴充一次（擴充為原來的1.5倍），但是這里顯示指明了需要多少空間，所以就一次性為你分配這么多空間，也就是不需要擴充了。
?
17. 下面哪些是對稱加密算法（）
A DES ? B AES ? C DSA ? D RSA
答案：AB
解析：常用的對稱加密算法有：DES、3DES、RC2、RC4、AES
常用的非對稱加密算法有：RSA、DSA、ECC
使用單向散列函數的加密算法：MD5、SHA
?
18.新建一個流對象，下面哪個選項的代碼是錯誤的？（）
A）new BufferedWriter(new FileWriter("a.txt"));
B）new BufferedReader(new FileInputStream("a.dat"));
C）new GZIPOutputStream(new FileOutputStream("a.zip"));
D）new ObjectInputStream(new FileInputStream("a.dat"));
答案：B
解析：請記得13題的那個圖嗎？Reader只能用FileReader進行實例化。
?
19. 下面程序能正常運行嗎（）
public class NULL {public static void haha(){System.out.println("haha");}public static void main(String[] args) {((NULL)null).haha();}}答案：能正常運行
解析：輸出為haha，因為null值可以強制轉換為任何java類類型,(String)null也是合法的。但null強制轉換后是無效對象，其返回值還是為null，而static方法的調用是和類名綁定的，不借助對象進行訪問所以能正確輸出。反過來，沒有static修飾就只能用對象進行訪問，使用null調用對象肯定會報空指針錯了。這里和C++很類似。這里感謝@Florian網友解答。
?
20. 下面程序的運行結果是什么（）
class HelloA {public HelloA() {System.out.println("HelloA");}{ System.out.println("I'm A class"); }static { System.out.println("static A"); }}public class HelloB extends HelloA {public HelloB() {System.out.println("HelloB");}{ System.out.println("I'm B class"); }static { System.out.println("static B"); }public static void main(String[] args) { new HelloB(); }}答案：
static A static B I'm A class HelloA I'm B class HelloB解析：說實話我覺得這題很好，考查靜態語句塊、構造語句塊（就是只有大括號的那塊）以及構造函數的執行順序。
對象的初始化順序：（1）類加載之后，按從上到下（從父類到子類）執行被static修飾的語句；（2）當static語句執行完之后,再執行main方法；（3）如果有語句new了自身的對象，將從上到下執行構造代碼塊、構造器（兩者可以說綁定在一起）。
下面稍微修改下上面的代碼，以便更清晰的說明情況：
?View Code此時輸出結果為：
static A static B -------main start------- I'm A class HelloA I'm B class HelloB I'm A class HelloA I'm B class HelloB -------main end-------?
21.?getCustomerInfo()方法如下，try中可以捕獲三種類型的異常，如果在該方法運行中產生了一個IOException，將會輸出什么結果（）
public void getCustomerInfo() {try {// do something that may cause an Exception} catch (java.io.FileNotFoundException ex) {System.out.print("FileNotFoundException!");} catch (java.io.IOException ex) {System.out.print("IOException!");} catch (java.lang.Exception ex) {System.out.print("Exception!");}}A?IOException!
BIOException!Exception!
CFileNotFoundException!IOException!
DFileNotFoundException!IOException!Exception!
答案：A
解析：考察多個catch語句塊的執行順序。當用多個catch語句時，catch語句塊在次序上有先后之分。從最前面的catch語句塊依次先后進行異常類型匹配，這樣如果父異常在子異常類之前，那么首先匹配的將是父異常類，子異常類將不會獲得匹配的機會，也即子異常類型所在的catch語句塊將是不可到達的語句。所以，一般將父類異常類即Exception老大放在catch語句塊的最后一個。
?
22. 下面代碼的運行結果為：（）
import java.io.*; import java.util.*;public class foo{public static void main (String[] args){String s;System.out.println("s=" + s);}}A?代碼得到編譯，并輸出“s=”
B?代碼得到編譯，并輸出“s=null”
C?由于String s沒有初始化，代碼不能編譯通過
D?代碼得到編譯，但捕獲到?NullPointException異常答案：C
解析：開始以為會輸出null什么的，運行后才發現Java中所有定義的基本類型或對象都必須初始化才能輸出值。
?
23. ?System.out.println("5" + 2);的輸出結果應該是（）。
A?52?????????????????? B7???????????????????? C2?????????????? ??????D5
答案：A
解析：沒啥好說的，Java會自動將2轉換為字符串。
?
24.?指出下列程序運行的結果?（）
public class Example {String str = new String("good");char[] ch = { 'a', 'b', 'c' };public static void main(String args[]) {Example ex = new Example();ex.change(ex.str, ex.ch);System.out.print(ex.str + " and ");System.out.print(ex.ch);}public void change(String str, char ch[]) {str = "test ok";ch[0] = 'g';} }A、?good and abc
B、?good and gbc
C、?test ok and abc
D、?test ok and gbc?答案：B
解析：大家可能以為Java中String和數組都是對象所以肯定是對象引用，然后就會選D，其實這是個很大的誤區：因為在java里沒有引用傳遞，只有值傳遞
這個值指的是實參的地址的拷貝，得到這個拷貝地址后，你可以通過它修改這個地址的內容（引用不變），因為此時這個內容的地址和原地址是同一地址，
但是你不能改變這個地址本身使其重新引用其它的對象，也就是值傳遞，可能說的不是很清楚，下面給出一個完整的能說明情況的例子吧：
?View Code程序有些啰嗦，但能反映問題，該程序運行結果為：
對象交換前：p1 = Alexia female 對象交換前：p2 = Edward male對象交換后：p1 = Alexia female 對象交換后：p2 = Edward male對象數組交換前：arraya[0] = Alexia female, arraya[1] = Edward male 對象數組交換前：arrayb[0] = jmwang female, arrayb[1] = hwu male對象數組交換后：arraya[0] = Alexia female, arraya[1] = Edward male 對象數組交換后：arrayb[0] = jmwang female, arrayb[1] = hwu male基本類型數組交換前：a[0] = 0, a[1] = 1 基本類型數組交換前：b[0] = 1, b[1] = 2基本類型數組交換后：a[0] = 0, a[1] = 1 基本類型數組交換后：b[0] = 1, b[1] = 2對象數組內容交換并改變后：arraya[1] = wjl male 對象數組內容交換并改變后：arrayb[1] = Edward male基本類型數組內容交換并改變后：a[1] = 5 基本類型數組內容交換并改變后：b[1] = 1說明：不管是對象、基本類型還是對象數組、基本類型數組，在函數中都不能改變其實際地址但能改變其中的內容。
? 25.?要從文件"file.dat"中讀出第10個字節到變量c中,下列哪個方法適合??（）A?FileInputStream in=new FileInputStream("file.dat"); in.skip(9); int c=in.read();
B?FileInputStream in=new FileInputStream("file.dat"); in.skip(10); int c=in.read();
C?FileInputStream in=new FileInputStream("file.dat"); int c=in.read();
D?RandomAccessFile in=new RandomAccessFile("file.dat"); in.skip(9); int c=in.readByte();
答案：A?D?
解析：long skip(long n)作用是跳過n個字節不讀，主要用在包裝流中的，因為一般流（如FileInputStream）只能順序一個一個的讀不能跳躍讀，但是包裝流可以用skip方法跳躍讀取。那么什么是包裝流呢？各種字節節點流類，它們都只具有讀寫字節內容的方法，以FileInputStream與FileOutputStream為例，它們只能在文件中讀取或者向文件中寫入字節，在實際應用中我們往往需要在文件中讀取或者寫入各種類型的數據，就必須先將其他類型的數據轉換成字節數組后寫入文件，或者從文件中讀取到的字節數組轉換成其他數據類型，想想都很麻煩！！因此想通過FileOutputStream將一個浮點小數寫入到文件中或將一個整數寫入到文件時是非常困難的。這時就需要包裝類DataInputStream/DataOutputStream，它提供了往各種輸入輸出流對象中讀入或寫入各種類型的數據的方法。
DataInputStream/DataOutputStream并沒有對應到任何具體的流設備，一定要給它傳遞一個對應具體流設備的輸入或輸出流對象，完成類似?DataInputStream/DataOutputStream功能的類就是一個包裝類，也叫過濾流類或處理流類。它對InputOutStream/OutputStream流類進行了包裝，使編程人員使用起來更方便。其中DataInputStream包裝類的構造函數語法：public DataInputStream(InputStream in)。包裝類也可以包裝另外一個包裝類。
首先BC肯定 是錯的，那A正確嗎？按上面的解析應該也不對，但我試了下，發現A也是正確的，與網上解析的資料有些出入，下面是我的code：
?View Code那么D呢，RandomAccessFile是IO包的類，但是其自成一派，從Object直接繼承而來。可以對文件進行讀取和寫入。支持文件的隨機訪問，即可以隨機讀取文件中的某個位置內容，這么說RandomAccessFile肯定可以達到題目的要求，但是選項有些錯誤，比如RandomAccessFile的初始化是兩個參數而非一個參數，采用的跳躍讀取方法是skipBytes()而非skip()，即正確的寫法是：
RandomAccessFile in = new RandomAccessFile("file.dat", "r"); in.skipBytes(9); int c = in.readByte();這樣也能讀到第十個字節，也就是A和D都能讀到第十個字節，那么到底該選哪個呢？A和D有啥不同嗎？求大神解答~~~
?
26.?下列哪種異常是檢查型異常，需要在編寫程序時聲明?（）
ANullPointerException??????? BClassCastException????? CFileNotFoundException?????? D IndexOutOfBoundsException?
答案：C
解析：看第2題的解析。
?
27. 下面的方法，當輸入為2的時候返回值是多少?（）
public static int getValue(int i) {int result = 0;switch (i) {case 1:result = result + i;case 2:result = result + i * 2;case 3:result = result + i * 3;}return result;}A0??????????????????? B2??????????????????? C4???????????????????? D10
答案：D
解析：注意這里case后面沒有加break，所以從case 2開始一直往下運行。
?
28.?選項中哪一行代碼可以替換題目中//add code here而不產生編譯錯誤？（）
public abstract class MyClass {public int constInt = 5;//add code herepublic void method() {} }
Apublic abstract void method(int a);
B constInt = constInt + 5;
C?public int method();
D?public abstract void anotherMethod() {}
答案：A
解析：考察抽象類的使用。
抽象類遵循的原則：
（1）abstract關鍵字只能修飾類和方法，不能修飾字段。 （2）抽象類不能被實例化（無法使用new關鍵字創建對象實例），只能被繼承。 （3）抽象類可以包含屬性，方法，構造方法，初始化塊，內部類，枚舉類，和普通類一樣，普通方法一定要實現，變量可以初始化或不初始化但不能初始化后在抽象類中重新賦值或操作該變量（只能在子類中改變該變量）。 （4）抽象類中的抽象方法（加了abstract關鍵字的方法）不能實現。 （5）含有抽象方法的類必須定義成抽象類。 擴展：抽象類和接口的區別，做個總結吧：（1）接口是公開的，里面不能有私有的方法或變量，是用于讓別人使用的，而抽象類是可以有私有方法或私有變量的。
（2）abstract class 在 Java 語言中表示的是一種繼承關系，一個類只能使用一次繼承關系。但是，一個類卻可以實現多個interface，實現多重繼承。接口還有標識（里面沒有任何方法，如Remote接口）和數據共享（里面的變量全是常量）的作用。
（3）在abstract class 中可以有自己的數據成員，也可以有非abstarct的成員方法，而在interface中，只能夠有靜態的不能被修改的數據成員（也就是必須是 static final的，不過在 interface中一般不定義數據成員），所有的成員方法默認都是 public abstract 類型的。
（4）abstract class和interface所反映出的設計理念不同。其實abstract class表示的是"is-a"關系，interface表示的是"has-a"關系。
（5）實現接口的一定要實現接口里定義的所有方法，而實現抽象類可以有選擇地重寫需要用到的方法，一般的應用里，最頂級的是接口，然后是抽象類實現接口，最后才到具體類實現。抽象類中可以有非抽象方法。接口中則不能有實現方法。
（6）接口中定義的變量默認是public static final 型，且必須給其初值，所以實現類中不能重新定義，也不能改變其值。抽象類中的變量默認是 friendly 型，其值可以在子類中重新定義，也可以在子類中重新賦值。
?
29. 閱讀Shape和Circle兩個類的定義。在序列化一個Circle的對象circle到文件時，下面哪個字段會被保存到文件中？?(? )
class Shape {public String name;}class Circle extends Shape implements Serializable{private float radius;transient int color;public static String type = "Circle";}Aname
B?radius
C?color
D?type
答案：B
解析：這里有詳細的解釋：http://www.cnblogs.com/lanxuezaipiao/p/3369962.html
?
30.下面是People和Child類的定義和構造方法，每個構造方法都輸出編號。在執行new Child("mike")的時候都有哪些構造方法被順序調用？請選擇輸出結果?( )
class People {String name;public People() {System.out.print(1);}public People(String name) {System.out.print(2);this.name = name;} }class Child extends People {People father;public Child(String name) {System.out.print(3);this.name = name;father = new People(name + ":F");}public Child() {System.out.print(4);}}A312????????????? B 32?????????????? C 432????????????? D 132
答案：D
解析：考察的又是父類與子類的構造函數調用次序。在Java中，子類的構造過程中必須調用其父類的構造函數，是因為有繼承關系存在時，子類要把父類的內容繼承下來。但如果父類有多個構造函數時，該如何選擇調用呢？
第一個規則：子類的構造過程中，必須調用其父類的構造方法。一個類，如果我們不寫構造方法，那么編譯器會幫我們加上一個默認的構造方法（就是沒有參數的構造方法），但是如果你自己寫了構造方法，那么編譯器就不會給你添加了，所以有時候當你new一個子類對象的時候，肯定調用了子類的構造方法，但是如果在子類構造方法中我們并沒有顯示的調用基類的構造方法，如：super();??這樣就會調用父類沒有參數的構造方法。????
第二個規則：如果子類的構造方法中既沒有顯示的調用基類構造方法，而基類中又沒有無參的構造方法，則編譯出錯，所以，通常我們需要顯示的：super(參數列表)，來調用父類有參數的構造函數，此時無參的構造函數就不會被調用。
總之，一句話：子類沒有顯示調用父類構造函數，不管子類構造函數是否帶參數都默認調用父類無參的構造函數，若父類沒有則編譯出錯。
?
最后，給大家出個思考題：下面程序的運行結果是什么？
public class Dervied extends Base {private String name = "dervied";public Dervied() {tellName();printName();}public void tellName() {System.out.println("Dervied tell name: " + name);}public void printName() {System.out.println("Dervied print name: " + name);}public static void main(String[] args){new Dervied(); } }class Base {private String name = "base";public Base() {tellName();printName();}public void tellName() {System.out.println("Base tell name: " + name);}public void printName() {System.out.println("Base print name: " + name);} }總結
以上是生活随笔為你收集整理的Java笔试题解答和部分面试题的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 转：libev和libevent的设计差
- 下一篇： Android 基础（十三） shape