java技術面試之面試題大全

轉載自：http://blog.csdn.net/lijizhi19950123/article/details/77679489

Java 面試知識點總結

本篇文章會對面試中常遇到的Java技術點進行全面深刻的總結，幫助咱們在面試中更加駕輕就熟，不參加面試的同窗也可以藉此機會梳理一下本身的知識體系，進行查漏補缺（閱讀本文須要有必定的Java基礎）。本文的問題列表來自於www.nowcoder.com/discuss/304…在此感謝原做者的無私分享：）

1. Java中的原始數據類型都有哪些，它們的大小及對應的封裝類是什麼？

• boolean
  boolean數據類型非true即false。這個數據類型表示1 bit，可是它的大小並無精肯定義。
  《Java虛擬機規範》中如是說：「雖然定義了boolean這種數據類型，可是隻對它提供了很是有限的支持。在Java虛擬機中沒有任何供boolean值專用的字節碼指令，Java語言表達式所操做的boolean值，在編譯以後都使用Java虛擬機中的int數據類型來代替，而boolean數組將會被編碼成Java虛擬機的byte數組，每一個元素boolean元素佔8位」。這樣咱們能夠得出boolean類型單獨使用是4個字節，在數組中又是1個字節。那虛擬機爲何要用int來代替boolean呢？爲何不用byte或short，這樣不是更節省內存空間嗎？實際上，使用int的緣由是，對於當下32位的CPU來講，一次進行32位的數據交換更加高效。
  綜上，咱們能夠知道：官方文檔對boolean類型沒有給出精確的定義，《Java虛擬機規範》給出了「單獨時使用4個字節，boolean數組時1個字節」的定義，具體還要看虛擬機實現是否按照規範來，因此1個字節、4個字節都是有可能的。這實際上是一種時空權衡。
  boolean類型的封裝類是Boolean。
• byte——1 byte——Byte
• short——2 bytes——Short
• int——4 bytes——Integer
• long——8 bytes——Long
• float——4 bytes——Float
• double——8 bytes——Double
• char——2 bytes——Character

2. 談一談」==「與」equals()"的區別。
《Think in Java》中說：「關係操做符生成的是一個boolean結果，它們計算的是操做數的值之間的關係」。
"=="判斷的是兩個對象的內存地址是否同樣，適用於原始數據類型和枚舉類型（它們的變量存儲的是值自己，而引用類型變量存儲的是引用）；equals是Object類的方法，Object對它的實現是比較內存地址，咱們能夠重寫這個方法來自定義「相等」這個概念。好比類庫中的String、Date等類就對這個方法進行了重寫。
綜上，對於枚舉類型和原始數據類型的相等性比較，應該使用"=="；對於引用類型的相等性比較，應該使用equals方法。

3. Java中的四種引用及其應用場景是什麼？

• 強引用: 一般咱們使用new操做符建立一個對象時所返回的引用即爲強引用

• 軟引用: 若一個對象只能經過軟引用到達，那麼這個對象在內存不足時會被回收，可用於圖片緩存中，內存不足時系統會自動回收再也不使用的Bitmap

• 弱引用: 若一個對象只能經過弱引用到達，那麼它就會被回收（即便內存充足），一樣可用於圖片緩存中，這時候只要Bitmap再也不使用就會被回收

• 虛引用: 虛引用是Java中最「弱」的引用，經過它甚至沒法獲取被引用的對象，它存在的惟一做用就是當它指向的對象回收時，它自己會被加入到引用隊列中，這樣咱們能夠知道它指向的對象什麼時候被銷燬。

4. object中定義了哪些方法？
clone(), equals(), hashCode(), toString(), notify(), notifyAll(), wait(), finalize(), getClass()

5. hashCode的做用是什麼？
請參見散列表的基本原理與實現

6. ArrayList, LinkedList, Vector的區別是什麼？

• ArrayList: 內部採用數組存儲元素，支持高效隨機訪問，支持動態調整大小

• LinkedList: 內部採用鏈表來存儲元素，支持快速插入/刪除元素，但不支持高效地隨機訪問

• Vector: 能夠看做線程安全版的ArrayList

7. String, StringBuilder, StringBuffer的區別是什麼？

• String: 不可變的字符序列，若要向其中添加新字符須要建立一個新的String對象

• StringBuilder: 可變字符序列，支持向其中添加新字符（無需建立新對象）

• StringBuffer: 能夠看做線程安全版的StringBuilder

8. Map, Set, List, Queue、Stack的特色及用法。

• Map: Java中存儲鍵值對的數據類型都實現了這個接口，表示「映射表」。支持的兩個核心操做是get(Object key)以及put(K key, V value)，分別用來獲取鍵對應的值以及向映射表中插入鍵值對。

• Set: 實現了這個接口的集合類型中不容許存在重複的元素，表明數學意義上的「集合」。它所支持的核心操做有add(E e), remove(Object o), contains(Object o)，分別用於添加元素，刪除元素以及判斷給定元素是否存在於集中。

• List: Java中集合框架中的列表類型都實現了這個接口，表示一種有序序列。支持get(int index), add(E e)等操做。

• Queue: Java集合框架中的隊列接口，表明了「先進先出」隊列。支持add(E element),remove()等操做。

• Stack: Java集合框架中表示堆棧的數據類型，堆棧是一種「後進先出」的數據結構。支持push(E item), pop()等操做。

更詳細的說明請參考官方文檔，對相關數據結構不太熟悉的同窗能夠參考《算法導論》或其餘相關書籍。

9. HashMap和HashTable的區別

• HashTable是線程安全的，而HashMap不是

• HashMap中容許存在null鍵和null值，而HashTable中不容許

10. HashMap的實現原理
簡單的說，HashMap的底層實現是「基於拉鍊法的散列表」。詳細分析請參考深刻解析HashMap、HashTable

11. ConcurrentHashMap的實現原理
ConcurrentHashMap是支持併發讀寫的HashMap，它的特色是讀取數據時無需加鎖，寫數據時能夠保證加鎖粒度儘量的小。因爲其內部採用「分段存儲」，只需對要進行寫操做的數據所在的「段」進行加鎖。關於ConcurrentHashMap底層實現的詳細分析請參考Java併發編程：併發容器之ConcurrentHashMap

12. TreeMap, LinkedHashMap, HashMap的區別是什麼？

• HashMap的底層實現是散列表，所以它內部存儲的元素是無序的；

• TreeMap的底層實現是紅黑樹，因此它內部的元素的有序的。排序的依據是天然序或者是建立TreeMap時所提供的比較器（Comparator）對象。

• LinkedHashMap能夠看做可以記住插入元素的順序的HashMap。

13. Collection與Collections的區別是什麼？

• Collection是Java集合框架中的基本接口；
• Collections是Java集合框架提供的一個工具類，其中包含了大量用於操做或返回集合的靜態方法。

14. 對於「try-catch-finally」，若try語句塊中包含「return」語句，finally語句塊會執行嗎？
會執行。只有兩種狀況finally塊中的語句不會被執行：**

• 調用了System.exit()方法；

• JVM「崩潰」了。

15. Java中的異常層次結構
Java中的異常層次結構以下圖所示：

咱們能夠看到Throwable類是異常層級中的基類。Error類表示內部錯誤，這類錯誤使咱們沒法控制的；Exception表示異常，RuntimeException及其子類屬於未檢查異常，這類異常包括ArrayIndexOutOfBoundsException、NullPointerException等，咱們應該經過條件判斷等方式語句避免未檢查異常的發生。IOException及其子類屬於已檢查異常，編譯器會檢查咱們是否爲全部可能拋出的已檢查異常提供了異常處理器，若沒有則會報錯。對於未檢查異常，咱們無需捕獲（固然Java也容許咱們捕獲，但咱們應該作的事避免未檢查異常的發生）。

16. Java面向對象的三個特徵與含義
三大特徵：封裝、繼承、多態。詳細介紹請戳Java面向對象三大特性

17. Override, Overload的含義與區別

• Override表示「重寫」，是子類對父類中同一方法的從新定義

• Overload表示「重載」，也就是定義一個與已定義方法名稱相同但簽名不一樣的新方法**

18. 接口與抽象類的區別

• 接口是一種約定，實現接口的類要遵循這個約定；

• 抽象類本質上是一個類，使用抽象類的代價要比接口大。

• 接口與抽象類的對好比下：

  • 抽象類中能夠包含屬性，方法（包含抽象方法與有着具體實現的方法），常量；接口只能包含常量和方法聲明。

  • 抽象類中的方法和成員變量能夠定義可見性（好比public、private等）；而接口中的方法只能爲public（缺省爲public）。

  • 一個子類只能有一個父類（具體類或抽象類）；而一個接口能夠繼承一個多個接口，一個類也能夠實現多個接口。

  • 子類中實現父類中的抽象方法時，可見性能夠大於等於父類中的；而接口實現類中的接口 方法的可見性只能與接口中相同（public）。

19. 靜態內部類與非靜態內部類的區別
靜態內部類不會持有外圍類的引用，而非靜態內部類會隱式持有外圍類的一個引用。

20. Java中多態的實現原理
所謂多態，指的就是父類引用指向子類對象，調用方法時會調用子類的實現而不是父類的實現。多態的實現的關鍵在於「動態綁定」。詳細介紹請戳Java動態綁定的內部實現機制

21. 簡述Java中建立新線程的兩種方法

• 繼承Thread類（假設子類爲MyThread），並重寫run()方法，而後new一個MyThread對象並對其調用start()便可啓動新線程。

• 實現Runnable接口（假設實現類爲MyRunnable），然後將MyRunnable對象做爲參數傳入Thread構造器，在獲得的Thread對象上調用start()方法便可。

22. 簡述Java中進行線程同步的方法

• volatile: Java Memory Model保證了對同一個volatile變量的寫happens before對它的讀；

• synchronized: 能夠來對一個代碼塊或是對一個方法上鎖，被「鎖住」的地方稱爲臨界區，進入臨界區的線程會獲取對象的monitor，這樣其餘嘗試進入臨界區的線程會因沒法獲取monitor而被阻塞。因爲等待另外一個線程釋放monitor而被阻塞的線程沒法被中斷。

• ReentrantLock: 嘗試獲取鎖的線程能夠被中斷並能夠設置超時參數。

23. 簡述Java中具備哪幾種粒度的鎖
Java中能夠對類、對象、方法或是代碼塊上鎖。

24. 給出「生產者-消費者」問題的一種解決方案
使用阻塞隊列：

public class BlockingQueueTest {
  private int size = 20;
  private ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(size);
  public static void main(String[] args) {
    BlockingQueueTest test = new BlockingQueueTest(); 
    Producer producer = test.new Producer(); 
    Consumer consumer = test.new Consumer(); 
    producer.start(); consumer.start(); 
  } 

  class Consumer extends Thread{ 
    @Override 
    public void run() { 
      while(true){ 
        try { 
          //從阻塞隊列中取出一個元素 
          queue.take(); 
          System.out.println("隊列剩餘" + queue.size() + "個元素"); 
        } catch (InterruptedException e) { 
        } 
      } 
    } 
  } 

  class Producer extends Thread{ 
    @Override 
    public void run() { 
      while (true) { 
        try { 
          //向阻塞隊列中插入一個元素 
          queue.put(1); 
          System.out.println("隊列剩餘空間：" + (size - queue.size())); 
        } catch (InterruptedException e) { 
        } 
      } 
    } 
  }
}

25. ThreadLocal的設計理念與做用
ThreadLocal的做用是提供線程內的局部變量，在多線程環境下訪問時能保證各個線程內的ThreadLocal變量各自獨立。也就是說，每一個線程的ThreadLocal變量是本身專用的，其餘線程是訪問不到的。ThreadLocal最經常使用於如下這個場景：多線程環境下存在對非線程安全對象的併發訪問，並且該對象不須要在線程間共享，可是咱們不想加鎖，這時候能夠使用ThreadLocal來使得每一個線程都持有一個該對象的副本。

26. concurrent包的總體架構

27. ArrayBlockingQueue, CountDownLatch類的做用

• CountDownLatch: 容許線程集等待直到計數器爲0。適用場景: 當一個或多個線程須要等待指定數目的事件發生後再繼續執行。

• ArrayBlockingQueue: 一個基於數組實現的阻塞隊列，它在構造時須要指定容量。當試圖向滿隊列中添加元素或者從空隊列中移除元素時，當前線程會被阻塞。經過阻塞隊列，咱們能夠按如下模式來工做：工做者線程能夠週期性的將中間結果放入阻塞隊列中，其它線程能夠取出中間結果並進行進一步操做。若工做者線程的執行比較慢（還沒來得及向隊列中插入元素），其餘從隊列中取元素的線程會等待它（試圖從空隊列中取元素從而阻塞）；若工做者線程執行較快（試圖向滿隊列中插入元素），則它會等待其它線程取出元素再繼續執行。

28. wait()，sleep() 的區別

• wait(): Object類中定義的實例方法。在指定對象上調用wait方法會讓當前線程進入等待狀態（前提是當前線程持有該對象的monitor），此時當前線程會釋放相應對象的monitor，這樣一來其它線程便有機會獲取這個對象的monitor了。當其它線程獲取了這個對象的monitor並進行了所需操做時，即可以調用notify方法喚醒以前進入等待狀態的線程。

• sleep(): Thread類中的靜態方法，做用是讓當前線程進入休眠狀態，以便讓其餘線程有機會執行。進入休眠狀態的線程不會釋放它所持有的鎖。

29. 線程池的用法與優點

• 優點: 實現對線程的複用，避免了反覆建立及銷燬線程的開銷；使用線程池統一管理線程能夠減小併發線程的數目，而線程數過多每每會在線程上下文切換上以及線程同步上浪費過多時間。

• 用法: 咱們能夠調用ThreadPoolExecutor的某個構造方法來本身建立一個線程池。但一般狀況下咱們能夠使用Executors類提供給咱們的靜態工廠方法來更方便的建立一個線程池對象。建立了線程池對象後，咱們就能夠調用submit方法提交任務到線程池中去執行了；線程池使用完畢後咱們要記得調用shutdown方法來關閉它。

30. for-each與常規for循環的效率對比
關於這個問題咱們直接看《Effective Java》給咱們作的解答：

for-each可以讓代碼更加清晰，而且減小了出錯的機會。
下面的慣用代碼適用於集合與數組類型：

for (Element e : elements) {
    doSomething(e);
}

使用for-each循環與常規的for循環相比，並不存在性能損失，即便對數組進行迭代也是如此。實際上，在有些場合下它還能帶來微小的性能提高，由於它只計算一次數組索引的上限。

31. 簡述Java IO與NIO的區別

• Java IO是面向流的，這意味着咱們須要每次從流中讀取一個或多個字節，直到讀取完全部字節；NIO是面向緩衝的，也就是說會把數據讀取到一個緩衝區中，而後對緩衝區中的數據進行相應處理。

• Java IO是阻塞IO，而NIO是非阻塞IO。

• Java NIO中存在一個稱爲選擇器（selector）的東西，它容許你把多個通道（channel）註冊到一個選擇器上，而後使用一個線程來監視這些通道：若這些通道里有某個準備好能夠開始進行讀或寫操做了，則開始對相應的通道進行讀寫。而在等待某通道變爲可讀/寫期間，請求對通道進行讀寫操做的線程能夠去幹別的事情。

32. 反射的做用與原理
反射的做用歸納地說是運行時獲取類的各類定義信息，好比定義了哪些屬性與方法。原理是經過類的class對象來獲取它的各類信息。

33. Java中的泛型機制
關於泛型機制的詳細介紹請直接戳Java核心技術點之泛型

34. Java 7與Java 8的新特性
這裏有兩篇總結的很是好的：
Java 7的新特性
Java 8的新特性

35. 常見設計模式
所謂「設計模式」，不過是面向對象編程中一些經常使用的軟件設計手法，而且通過實踐的檢驗，這些設計手法在各自的場景下能解決一些需求，所以它們就成爲了現在廣爲流傳的」設計模式「。也就是說，正式由於在某些場景下產生了一些棘手的問題，才催生了相應的設計模式。明確了這一點，咱們在學習某種設計模式時要充分理解它產生的背景以及它所解決的主要矛盾是什麼。

經常使用的設計模式能夠分爲如下三大類：

• 建立型模式: 包括工廠模式（又可進一步分爲簡單工廠模式、工廠方法模式、抽象工廠模式）、建造者模式、單例模式。

• 結構型模式: 包括適配器模式、橋接模式、裝飾模式、外觀模式、享元模式、代理模式。

• 行爲型模式: 包括命令模式、中介者模式、觀察者模式、狀態模式、策略模式。

  關於每一個模式具體的介紹請參考圖說設計模式

36. JNI的基本用法
關於JNI，這裏有篇好文：Android中的JNI

37. 動態代理的定義、應用場景及原理
請參見十分鐘理解Java之動態代理

38. 註解的基本概念與使用
註解能夠看做是「加強版的註釋」，它能夠向編譯器、虛擬機說明一些事情。
註解是描述Java代碼的代碼，它可以被編譯器解析，註解處理工具在運行時也可以解析註解。註解自己是「被動」的信息，只有主動解析它纔有意義。
除了向編譯器/虛擬機傳遞信息，咱們也能夠使用註解來生成一些「模板化」的代碼。

Java 方向如何準備 BAT 技術面試答案 (彙總版)

1.面向對象和麪向過程的區別

面向過程
優勢：性能比面向對象高，由於類調用時須要實例化，開銷比較大，比較消耗資源;好比單片機、嵌入式開發、Linux/Unix等通常採用面向過程開發，性能是最重要的因素。
缺點：沒有面向對象易維護、易複用、易擴展
面向對象
優勢：易維護、易複用、易擴展，因爲面向對象有封裝、繼承、多態性的特性，能夠設計出低耦合的系統，使系統更加靈活、更加易於維護
缺點：性能比面向過程低

2.Java的四個基本特性（抽象、封裝、繼承，多態）

抽象：就是把現實生活中的某一類東西提取出來，用程序代碼表示，咱們一般叫作類或者接口。抽象包括兩個方面：一個是數據抽象，一個是過程抽象。數據抽象也就是對象的屬性。過程抽象是對象的行爲特徵。
封裝：把客觀事物封裝成抽象的類，而且類能夠把本身的數據和方法只讓可信的類或者對象操做，對不可信的進行封裝隱藏。封裝分爲屬性的封裝和方法的封裝。
繼承：是對有着共同特性的多類事物，進行再抽象成一個類。這個類就是多類事物的父類。父類的意義在於抽取多類事物的共性。
多態：容許不一樣類的對象對同一消息作出響應。方法的重載、類的覆蓋正體現了多態。

3.重載和重寫的區別

重載：發生在同一個類中，方法名必須相同，參數類型不一樣、個數不一樣、順序不一樣，方法返回值和訪問修飾符能夠不一樣，發生在編譯時。
重寫：發生在父子類中，方法名、參數列表必須相同，返回值小於等於父類，拋出的異常小於等於父類，訪問修飾符大於等於父類；若是父類方法訪問修飾符爲private則子類中就不是重寫。

4.構造器Constructor是否可被override

構造器不能被重寫，不能用static修飾構造器，只能用public
private protected這三個權限修飾符，且不能有返回語句。

5.訪問控制符public,protected,private,以及默認的區別

private只有在本類中才能訪問；
public在任何地方都能訪問；
protected在同包內的類及包外的子類能訪問；
默認不寫在同包內能訪問。
6是否能夠繼承String類#
String類是final類故不能夠繼承，一切由final修飾過的都不能繼承。

7.String和StringBuffer、StringBuilder的區別

可變性
String類中使用字符數組保存字符串，private
final char value[]，因此string對象是不可變的。StringBuilder與StringBuffer都繼承自AbstractStringBuilder類，在AbstractStringBuilder中也是使用字符數組保存字符串，char[]
value，這兩種對象都是可變的。
線程安全性
String中的對象是不可變的，也就能夠理解爲常量，線程安全。AbstractStringBuilder是StringBuilder與StringBuffer的公共父類，定義了一些字符串的基本操做，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer對方法加了同步鎖或者對調用的方法加了同步鎖，因此是線程安全的。StringBuilder並無對方法進行加同步鎖，因此是非線程安全的。
性能
每次對String 類型進行改變的時候，都會生成一個新的String 對象，而後將指針指向新的String 對象。StringBuffer每次都會對
StringBuffer 對象自己進行操做，而不是生成新的對象並改變對象引用。相同狀況下使用
StirngBuilder 相比使用
StringBuffer 僅能得到10%~15% 左右的性能提高，但卻要冒多線程不安全的風險。

8.hashCode和equals方法的關係

equals相等，hashcode必相等；hashcode相等，equals可能不相等。

9.抽象類和接口的區別

語法層次
抽象類和接口分別給出了不一樣的語法定義。
設計層次
抽象層次不一樣，抽象類是對類抽象，而接口是對行爲的抽象。抽象類是對整個類總體進行抽象，包括屬性、行爲，可是接口倒是對類局部（行爲）進行抽象。抽象類是自底向上抽象而來的，接口是自頂向下設計出來的。
跨域不一樣
抽象類所體現的是一種繼承關係，要想使得繼承關係合理，父類和派生類之間必須存在"is-a"
關係，即父類和派生類在概念本質上應該是相同的。對於接口則否則，並不要求接口的實現者和接口定義在概念本質上是一致的，僅僅是實現了接口定義的契約而已，"like-a"的關係。

10.自動裝箱與拆箱

裝箱：將基本類型用它們對應的引用類型包裝起來；
拆箱：將包裝類型轉換爲基本數據類型；
Java使用自動裝箱和拆箱機制，節省了經常使用數值的內存開銷和建立對象的開銷，提升了效率，由編譯器來完成，編譯器會在編譯期根據語法決定是否進行裝箱和拆箱動做。

11.什麼是泛型、爲何要使用以及泛型擦除

泛型，即「參數化類型」。
建立集合時就指定集合元素的類型，該集合只能保存其指定類型的元素，避免使用強制類型轉換。
Java編譯器生成的字節碼是不包涵泛型信息的，泛型類型信息將在編譯處理是被擦除，這個過程即類型擦除。泛型擦除能夠簡單的理解爲將泛型java代碼轉換爲普通java代碼，只不過編譯器更直接點，將泛型java代碼直接轉換成普通java字節碼。
類型擦除的主要過程以下：
1）.將全部的泛型參數用其最左邊界（最頂級的父類型）類型替換。
2）.移除全部的類型參數。

12.Java中的集合類及關係圖

List和Set繼承自Collection接口。
Set無序不容許元素重複。HashSet和TreeSet是兩個主要的實現類。
List有序且容許元素重複。ArrayList、LinkedList和Vector是三個主要的實現類。
Map也屬於集合系統，但和Collection接口不要緊。Map是key對value的映射集合，其中key列就是一個集合。key不能重複，可是value能夠重複。HashMap、TreeMap和Hashtable是三個主要的實現類。
SortedSet和SortedMap接口對元素按指定規則排序，SortedMap是對key列進行排序。

13.HashMap實現原理

具體原理參考文章：
zhangshixi.iteye.com/blog/672697
www.admin10000.com/document/33…

14.HashTable實現原理

具體原理參考文章：
www.cnblogs.com/skywang1234…
blog.csdn.net/chdjj/artic…

15.HashMap和HashTable區別

1）.HashTable的方法前面都有synchronized來同步，是線程安全的；HashMap未經同步，是非線程安全的。
2）.HashTable不容許null值(key和value都不能夠) ；HashMap容許null值(key和value均可以)。
3）.HashTable有一個contains(Object
value)功能和containsValue(Object
value)功能同樣。
4）.HashTable使用Enumeration進行遍歷；HashMap使用Iterator進行遍歷。
5）.HashTable中hash數組默認大小是11，增長的方式是old*2+1；HashMap中hash數組的默認大小是16，並且必定是2的指數。
6）.哈希值的使用不一樣，HashTable直接使用對象的hashCode； HashMap從新計算hash值，並且用與代替求模。

16.ArrayList和vector區別

ArrayList和Vector都實現了List接口，都是經過數組實現的。
Vector是線程安全的，而ArrayList是非線程安全的。
List第一次建立的時候，會有一個初始大小，隨着不斷向List中增長元素，當List 認爲容量不夠的時候就會進行擴容。Vector缺省狀況下自動增加原來一倍的數組長度，ArrayList增加原來的50%。

17.ArrayList和LinkedList區別及使用場景

區別
ArrayList底層是用數組實現的，能夠認爲ArrayList是一個可改變大小的數組。隨着愈來愈多的元素被添加到ArrayList中，其規模是動態增長的。
LinkedList底層是經過雙向鏈表實現的， LinkedList和ArrayList相比，增刪的速度較快。可是查詢和修改值的速度較慢。同時，LinkedList還實現了Queue接口，因此他還提供了offer(),
peek(), poll()等方法。
使用場景
LinkedList更適合從中間插入或者刪除（鏈表的特性）。
ArrayList更適合檢索和在末尾插入或刪除（數組的特性）。

18.Collection和Collections的區別

java.util.Collection 是一個集合接口。它提供了對集合對象進行基本操做的通用接口方法。Collection接口在Java 類庫中有不少具體的實現。Collection接口的意義是爲各類具體的集合提供了最大化的統一操做方式。
java.util.Collections 是一個包裝類。它包含有各類有關集合操做的靜態多態方法。此類不能實例化，就像一個工具類，服務於Java的Collection框架。

19.Concurrenthashmap實現原理

具體原理參考文章：
www.cnblogs.com/ITtangtang/…
ifeve.com/concurrenth…

20.Error、Exception區別

Error類和Exception類的父類都是throwable類，他們的區別是：
Error類通常是指與虛擬機相關的問題，如系統崩潰，虛擬機錯誤，內存空間不足，方法調用棧溢等。對於這類錯誤的致使的應用程序中斷，僅靠程序自己沒法恢復和和預防，遇到這樣的錯誤，建議讓程序終止。
Exception類表示程序能夠處理的異常，能夠捕獲且可能恢復。遇到這類異常，應該儘量處理異常，使程序恢復運行，而不該該隨意終止異常。

21.Unchecked

Exception和Checked Exception，各列舉幾個#
Unchecked Exception:
a. 指的是程序的瑕疵或邏輯錯誤，而且在運行時沒法恢復。
b. 包括Error與RuntimeException及其子類，如：OutOfMemoryError,
UndeclaredThrowableException, IllegalArgumentException,
IllegalMonitorStateException, NullPointerException, IllegalStateException,
IndexOutOfBoundsException等。
c. 語法上不須要聲明拋出異常。

Checked Exception:
a. 表明程序不能直接控制的無效外界狀況（如用戶輸入，數據庫問題，網絡異常，文件丟失等）
b. 除了Error和RuntimeException及其子類以外，如：ClassNotFoundException,
NamingException, ServletException, SQLException, IOException等。
c. 須要try catch處理或throws聲明拋出異常。

22.Java中如何實現代理機制(JDK、CGLIB)

JDK動態代理：代理類和目標類實現了共同的接口，用到InvocationHandler接口。
CGLIB動態代理：代理類是目標類的子類，用到MethodInterceptor接口。

23.多線程的實現方式

繼承Thread類、實現Runnable接口、使用ExecutorService、Callable、Future實現有返回結果的多線程。

24.線程的狀態轉換

20140828202610671.jpg

25.如何中止一個線程

參考文章：
www.cnblogs.com/greta/p/562…

26.什麼是線程安全

線程安全就是多線程訪問同一代碼，不會產生不肯定的結果。

27.如何保證線程安全

對非安全的代碼進行加鎖控制；
使用線程安全的類；
多線程併發狀況下，線程共享的變量改成方法級的局部變量。

28.synchronized如何使用

synchronized是Java中的關鍵字，是一種同步鎖。它修飾的對象有如下幾種：
1). 修飾一個代碼塊，被修飾的代碼塊稱爲同步語句塊，其做用的範圍是大括號{}括起來的代碼，做用的對象是調用這個代碼塊的對象；
2). 修飾一個方法，被修飾的方法稱爲同步方法，其做用的範圍是整個方法，做用的對象是調用這個方法的對象；
3). 修改一個靜態的方法，其做用的範圍是整個靜態方法，做用的對象是這個類的全部對象；
4). 修改一個類，其做用的範圍是synchronized後面括號括起來的部分，做用主的對象是這個類的全部對象。

29.synchronized和Lock的區別

主要相同點：Lock能完成synchronized所實現的全部功能
主要不一樣點：Lock有比synchronized更精確的線程語義和更好的性能。Lock的鎖定是經過代碼實現的，而synchronized是在JVM層面上實現的，synchronized會自動釋放鎖，而Lock必定要求程序員手工釋放，而且必須在finally從句中釋放。Lock還有更強大的功能，例如，它的tryLock方法能夠非阻塞方式去拿鎖。Lock鎖的範圍有侷限性，塊範圍，而synchronized能夠鎖住塊、對象、類。

30.多線程如何進行信息交互

void notify() 喚醒在此對象監視器上等待的單個線程。
void notifyAll() 喚醒在此對象監視器上等待的全部線程。
void wait() 致使當前的線程等待，直到其餘線程調用此對象的notify()方法或notifyAll()方法。
void wait(long timeout) 致使當前的線程等待，直到其餘線程調用此對象的notify()方法或notifyAll()方法，或者超過指定的時間量。
void wait(long timeout, int nanos) 致使當前的線程等待，直到其餘線程調用此對象的notify()方法或notifyAll()方法，或者其餘某個線程中斷當前線程，或者已超過某個實際時間量。

31.sleep和wait的區別(考察的方向是是否會釋放鎖)

sleep()方法是Thread類中方法，而wait()方法是Object類中的方法。
sleep()方法致使了程序暫停執行指定的時間，讓出cpu該其餘線程，可是他的監控狀態依然保持者，當指定的時間到了又會自動恢復運行狀態，在調用sleep()方法的過程當中，線程不會釋放對象鎖。而當調用wait()方法的時候，線程會放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象調用notify()方法後本線程才進入對象鎖定池準備。

32.多線程與死鎖

死鎖是指兩個或兩個以上的進程在執行過程當中，因爭奪資源而形成的一種互相等待的現象，若無外力做用，它們都將沒法推動下去。
產生死鎖的緣由：
一.由於系統資源不足。
二.進程運行推動的順序不合適。
三.資源分配不當。

33.如何才能產生死鎖

產生死鎖的四個必要條件：
一.互斥條件：所謂互斥就是進程在某一時間內獨佔資源。
二.請求與保持條件：一個進程因請求資源而阻塞時，對已得到的資源保持不放。
三.不剝奪條件:進程已得到資源，在末使用完以前，不能強行剝奪。
四.循環等待條件:若干進程之間造成一種頭尾相接的循環等待資源關係。

34.死鎖的預防

打破產生死鎖的四個必要條件中的一個或幾個，保證系統不會進入死鎖狀態。
一.打破互斥條件。即容許進程同時訪問某些資源。可是，有的資源是不容許被同時訪問的，像打印機等等，這是由資源自己的屬性所決定的。因此，這種辦法並沒有實用價值。
二.打破不可搶佔條件。即容許進程強行從佔有者那裏奪取某些資源。就是說，當一個進程已佔有了某些資源，它又申請新的資源，但不能當即被知足時，它必須釋放所佔有的所有資源，之後再從新申請。它所釋放的資源能夠分配給其它進程。這就至關於該進程佔有的資源被隱蔽地強佔了。這種預防死鎖的方法實現起來困難，會下降系統性能。
三.打破佔有且申請條件。能夠實行資源預先分配策略。即進程在運行前一次性地向系統申請它所須要的所有資源。若是某個進程所需的所有資源得不到知足，則不分配任何資源，此進程暫不運行。只有當系統可以知足當前進程的所有資源需求時，才一次性地將所申請的資源所有分配給該進程。因爲運行的進程已佔有了它所需的所有資源，因此不會發生佔有資源又申請資源的現象，所以不會發生死鎖。
四.打破循環等待條件，實行資源有序分配策略。採用這種策略，即把資源事先分類編號，按號分配，使進程在申請，佔用資源時不會造成環路。全部進程對資源的請求必須嚴格按資源序號遞增的順序提出。進程佔用了小號資源，才能申請大號資源，就不會產生環路，從而預防了死鎖。

35.什麼叫守護線程，用什麼方法實現守護線程

守護線程是爲其餘線程的運行提供服務的線程。
setDaemon(boolean on)方法能夠方便的設置線程的Daemon模式，true爲守護模式，false爲用戶模式。

36.Java線程池技術及原理

參考文章：
www.importnew.com/19011.html
www.cnblogs.com/dolphin0520…

37.java併發包concurrent及經常使用的類

這個內容有點多，參考文章：
併發包諸類概覽：www.raychase.net/1912
線程池：www.cnblogs.com/dolphin0520…
鎖： www.cnblogs.com/dolphin0520…
集合：www.cnblogs.com/huangfox/ar…

38.volatile關鍵字

用volatile修飾的變量，線程在每次使用變量的時候，都會讀取變量修改後的最的值。volatile很容易被誤用，用來進行原子性操做。
Java語言中的volatile變量能夠被看做是一種「程度較輕的
synchronized」；與
synchronized 塊相比，volatile 變量所需的編碼較少，而且運行時開銷也較少，可是它所能實現的功能也僅是synchronized的一部分。鎖提供了兩種主要特性：互斥（mutual
exclusion）和可見性（visibility）。互斥即一次只容許一個線程持有某個特定的鎖，所以可以使用該特性實現對共享數據的協調訪問協議，這樣，一次就只有一個線程可以使用該共享數據。可見性必須確保釋放鎖以前對共享數據作出的更改對於隨後得到該鎖的另外一個線程是可見的，若是沒有同步機制提供的這種可見性保證，線程看到的共享變量多是修改前的值或不一致的值，這將引起許多嚴重問題。Volatile變量具備synchronized的可見性特性，可是不具有原子特性。這就是說線程可以自動發現volatile
變量的最新值。
要使volatile變量提供理想的線程安全，必須同時知足下面兩個條件：對變量的寫操做不依賴於當前值；該變量沒有包含在具備其餘變量的不變式中。
第一個條件的限制使volatile變量不能用做線程安全計數器。雖然增量操做（x++）看上去相似一個單獨操做，實際上它是一個由讀取－修改－寫入操做序列組成的組合操做，必須以原子方式執行，而volatile不能提供必須的原子特性。實現正確的操做須要使x 的值在操做期間保持不變，而volatile
變量沒法實現這點。
每個線程運行時都有一個線程棧，線程棧保存了線程運行時候變量值信息。當線程訪問某一個對象時候值的時候，首先經過對象的引用找到對應在堆內存的變量的值，而後把堆內存變量的具體值load到線程本地內存中，創建一個變量副本，以後線程就再也不和對象在堆內存變量值有任何關係，而是直接修改副本變量的值，在修改完以後的某一個時刻（線程退出以前），自動把線程變量副本的值回寫到對象在堆中變量。這樣在堆中的對象的值就產生變化了。

read and load 從主存複製變量到當前工做內存
use and assign 執行代碼，改變共享變量值
store and write 用工做內存數據刷新主存相關內容
其中use and
assign 能夠屢次出現，可是這一些操做並非原子性，也就是在read load以後，若是主內存count變量發生修改以後，線程工做內存中的值因爲已經加載，不會產生對應的變化，因此計算出來的結果會和預期不同。

39.Java中的NIO，BIO，AIO分別是什麼

BIO:同步並阻塞，服務器實現模式爲一個鏈接一個線程，即客戶端有鏈接請求時服務器端就須要啓動一個線程進行處理，若是這個鏈接不作任何事情會形成沒必要要的線程開銷，固然能夠經過線程池機制改善。BIO方式適用於鏈接數目比較小且固定的架構，這種方式對服務器資源要求比較高，併發侷限於應用中，JDK1.4之前的惟一選擇，但程序直觀簡單易理解。
NIO:同步非阻塞，服務器實現模式爲一個請求一個線程，即客戶端發送的鏈接請求都會註冊到多路複用器上，多路複用器輪詢到鏈接有I/O請求時才啓動一個線程進行處理。NIO方式適用於鏈接數目多且鏈接比較短（輕操做）的架構，好比聊天服務器，併發侷限於應用中，編程比較複雜，JDK1.4開始支持。
AIO:異步非阻塞，服務器實現模式爲一個有效請求一個線程，客戶端的I/O請求都是由OS先完成了再通知服務器應用去啓動線程進行處理.AIO方式使用於鏈接數目多且鏈接比較長（重操做）的架構，好比相冊服務器，充分調用OS參與併發操做，編程比較複雜，JDK7開始支持。

40.IO和NIO區別

一.IO是面向流的，NIO是面向緩衝區的。
二.IO的各類流是阻塞的，NIO是非阻塞模式。
三.Java NIO的選擇器容許一個單獨的線程來監視多個輸入通道，你能夠註冊多個通道使用一個選擇器，而後使用一個單獨的線程來「選擇」通道：這些通道里已經有能夠處理的輸入，或者選擇已準備寫入的通道。這種選擇機制，使得一個單獨的線程很容易來管理多個通道。

41.序列化與反序列化

把對象轉換爲字節序列的過程稱爲對象的序列化。
把字節序列恢復爲對象的過程稱爲對象的反序列化。
對象的序列化主要有兩種用途：
一.把對象的字節序列永久地保存到硬盤上，一般存放在一個文件中；
二.在網絡上傳送對象的字節序列。
當兩個進程在進行遠程通訊時，彼此能夠發送各類類型的數據。不管是何種類型的數據，都會以二進制序列的形式在網絡上傳送。發送方須要把這個Java對象轉換爲字節序列，才能在網絡上傳送；接收方則須要把字節序列再恢復爲Java對象。

42.常見的序列化協議有哪些

Protobuf, Thrift, Hessian, Kryo

43.內存溢出和內存泄漏的區別

內存溢出是指程序在申請內存時，沒有足夠的內存空間供其使用，出現out of
memory。
內存泄漏是指分配出去的內存再也不使用，可是沒法回收。

44.Java內存模型及各個區域的OOM，如何重現OOM

這部份內容很重要，詳細閱讀《深刻理解Java虛擬機》，也能夠詳細閱讀這篇文章hllvm.group.iteye.com/group/wiki/…

45.出現OOM如何解決

一. 可經過命令按期抓取heap dump或者啓動參數OOM時自動抓取heap dump文件。
二. 經過對比多個heap dump，以及heap dump的內容，分析代碼找出內存佔用最多的地方。
三. 分析佔用的內存對象，是不是由於錯誤致使的內存未及時釋放，或者數據過多致使的內存溢出。

46.用什麼工具能夠查出內存泄漏

一. Memory
Analyzer－是一款開源的JAVA內存分析軟件，查找內存泄漏，能容易找到大塊內存並驗證誰在一直佔用它，它是基於Eclipse
RCP(Rich Client Platform)，能夠下載RCP的獨立版本或者Eclipse的插件。
二. JProbe－分析Java的內存泄漏。
三.JProfiler－一個全功能的Java剖析工具，專用於分析J2SE和J2EE應用程序。它把CPU、執行緒和內存的剖析組合在一個強大的應用中，GUI能夠找到效能瓶頸、抓出內存泄漏、並解決執行緒的問題。
四. JRockit－用來診斷Java內存泄漏並指出根本緣由，專門針對Intel平臺並獲得優化，能在Intel硬件上得到最高的性能。
五. YourKit-.NET & Java Profiling業界領先的Java和.NET程序性能分析工具。
六.AutomatedQA －AutomatedQA的獲獎產品performance profiling和memory debugging工具集的下一代替換產品，支持Microsoft,Borland, Intel, Compaq 和 GNU編譯器。能夠爲.NET和Windows程序生成全面細緻的報告，從而幫助您輕鬆隔離並排除代碼中含有的性能問題和內存/資源泄露問題。支持.Net 1.0,1.1,2.0,3.0和Windows 32/64位應用程序。
七.Compuware DevPartner Java Edition－包含Java內存檢測,代碼覆蓋率測試,代碼性能測試,線程死鎖,分佈式應用等幾大功能模塊

47.Java內存管理及回收算法

閱讀這篇文章：www.cnblogs.com/hnrainll/ar…

48.Java類加載器及如何加載類(雙親委派)

閱讀文章：
www.ibm.com/developerwo…
blog.csdn.net/zhoudaxia/a…

49.xml解析方式

一.DOM(JAXP
Crimson解析器)
二.SAX
三.JDOM
四.DOM4J
區別：
一.DOM4J性能最好，連Sun的JAXM也在用DOM4J。目前許多開源項目中大量採用DOM4J，例如大名鼎鼎的hibernate也用DOM4J來讀取XML配置文件。若是不考慮可移植性，那就採用DOM4J.
二.JDOM和DOM在性能測試時表現不佳，在測試10M
文檔時內存溢出。在小文檔狀況下還值得考慮使用DOM和JDOM。雖然JDOM的開發者已經說明他們指望在正式發行版前專一性能問題，可是從性能觀點來看，它確實沒有值得推薦之處。另外，DOM還是一個很是好的選擇。DOM實現普遍應用於多種編程語言。它仍是許多其它與XML相關的標準的基礎，由於它正式得到W3C
推薦(與基於非標準的Java模型相對)，因此在某些類型的項目中可能也須要它(如在JavaScript中使用DOM)。
三.SAX表現較好，這要依賴於它特定的解析方式－事件驅動。一個SAX檢測即將到來的XML流，但並無載入到內存(固然當XML流被讀入時，會有部分文檔暫時隱藏在內存中)。

50.Statement和PreparedStatement之間的區別

一.PreparedStatement是預編譯的,對於批量處理能夠大大提升效率. 也叫JDBC存儲過程
二.使用
Statement 對象。在對數據庫只執行一次性存取的時侯，用
Statement 對象進行處理。PreparedStatement
對象的開銷比Statement大，對於一次性操做並不會帶來額外的好處。
三.statement每次執行sql語句，相關數據庫都要執行sql語句的編譯，preparedstatement是預編譯得,
preparedstatement支持批處理
四.
代碼片斷1:
String updateString = "UPDATE COFFEES SET SALES = 75 " + "WHERE
COF_NAME LIKE ′Colombian′";
stmt.executeUpdate(updateString);
代碼片斷2:
PreparedStatement updateSales = con.prepareStatement("UPDATE COFFEES SET
SALES = ? WHERE COF_NAME LIKE ? ");
updateSales.setInt(1, 75);
updateSales.setString(2, "Colombian");
updateSales.executeUpdate();
片段2和片段1的區別在於，後者使用了PreparedStatement對象，而前者是普通的Statement對象。PreparedStatement對象不只包含了SQL語句，並且大多數狀況下這個語句已經被預編譯過，於是當其執行時，只需DBMS運行SQL語句，而沒必要先編譯。當你須要執行Statement對象屢次的時候，PreparedStatement對象將會大大下降運行時間，固然也加快了訪問數據庫的速度。
這種轉換也給你帶來很大的便利，沒必要重複SQL語句的句法，而只需更改其中變量的值，即可從新執行SQL語句。選擇PreparedStatement對象與否，在於相同句法的SQL語句是否執行了屢次，並且兩次之間的差異僅僅是變量的不一樣。若是僅僅執行了一次的話，它應該和普通的對象毫無差別，體現不出它預編譯的優越性。
五.執行許多SQL語句的JDBC程序產生大量的Statement和PreparedStatement對象。一般認爲PreparedStatement對象比Statement對象更有效,特別是若是帶有不一樣參數的同一SQL語句被屢次執行的時候。PreparedStatement對象容許數據庫預編譯SQL語句，這樣在隨後的運行中能夠節省時間並增長代碼的可讀性。
然而，在Oracle環境中，開發人員實際上有更大的靈活性。當使用Statement或PreparedStatement對象時，Oracle數據庫會緩存SQL語句以便之後使用。在一些狀況下,因爲驅動器自身須要額外的處理和在Java應用程序和Oracle服務器間增長的網絡活動，執行PreparedStatement對象實際上會花更長的時間。
然而，除了緩衝的問題以外，至少還有一個更好的緣由使咱們在企業應用程序中更喜歡使用PreparedStatement對象,那就是安全性。傳遞給PreparedStatement對象的參數能夠被強制進行類型轉換，使開發人員能夠確保在插入或查詢數據時與底層的數據庫格式匹配。
當處理公共Web站點上的用戶傳來的數據的時候，安全性的問題就變得極爲重要。傳遞給PreparedStatement的字符串參數會自動被驅動器忽略。最簡單的狀況下，這就意味着當你的程序試着將字符串「D'Angelo」插入到VARCHAR2中時，該語句將不會識別第一個「，」，從而致使悲慘的失敗。幾乎不多有必要建立你本身的字符串忽略代碼。
在Web環境中，有惡意的用戶會利用那些設計不完善的、不能正確處理字符串的應用程序。特別是在公共Web站點上,在沒有首先經過PreparedStatement對象處理的狀況下，全部的用戶輸入都不該該傳遞給SQL語句。此外，在用戶有機會修改SQL語句的地方，如HTML的隱藏區域或一個查詢字符串上，SQL語句都不該該被顯示出來。

51.servlet生命週期及各個方法

參考文章www.cnblogs.com/xuekyo/arch…

52.servlet中如何自定義filter

參考文章www.cnblogs.com/javawebsoa/…

53.JSP原理

參考文章blog.csdn.net/hanxuemin12…

54.JSP和Servlet的區別

(1)JSP經編譯後就變成了「類servlet」。
(2)JSP由HTML代碼和JSP標籤構成，更擅長頁面顯示；Servlet更擅長流程控制。
(3)JSP中嵌入JAVA代碼，而Servlet中嵌入HTML代碼。

55.JSP的動態include和靜態include

(1)動態include用jsp:include動做實現，如<jsp:include page="abc.jsp" flush="true" />，它老是會檢查所含文件中的變化，適合用於包含動態頁面，而且能夠帶參數。會先解析所要包含的頁面，解析後和主頁面合併一塊兒顯示，即先編譯後包含。
(2)靜態include用include僞碼實現，不會檢查所含文件的變化，適用於包含靜態頁面，如<%@
include file="qq.htm" %>，不會提早解析所要包含的頁面，先把要顯示的頁面包含進來，而後統一編譯，即先包含後編譯。

56.Struts中請求處理過程

參考文章www.cnblogs.com/liuling/p/2…

57.MVC概念

參考文章www.cnblogs.com/scwyh/artic…

58.Springmvc與Struts區別

參考文章：
blog.csdn.net/tch918/arti…
blog.csdn.net/chenleixing…

59.Hibernate/Ibatis二者的區別

參考文章blog.csdn.net/firejuly/ar…

60.Hibernate一級和二級緩存

參考文章blog.csdn.net/windrui/art…

61.簡述Hibernate常見優化策略

參考文章blog.csdn.net/shimiso/art…

62.Springbean的加載過程(推薦看Spring的源碼)

參考文章geeekr.com/read-spring…

63.Springbean的實例化(推薦看Spring的源碼)

參考文章geeekr.com/read-spring…

64.Spring如何實現AOP和IOC(推薦看Spring的源碼)

參考文章www.360doc.com/content/15/…

65.Springbean注入方式

參考文章blessht.iteye.com/blog/116213…

66.Spring的事務管理

這個主題的參考文章沒找到特別好的，blog.csdn.net/trigl/artic…

67.Spring事務的傳播特性

參考文章blog.csdn.net/lfsf802/art…

68.springmvc原理

參考文章blog.sina.com.cn/s/blog_7ef0…

69.springmvc用過哪些註解

參考文章aijuans.iteye.com/blog/216014…

70.Restful有幾種請求

參考文章，www.infoq.com/cn/articles…

71.Restful好處

(1)客戶-服務器：客戶-服務器約束背後的原則是分離關注點。經過分離用戶接口和數據存儲這兩個關注點，改善了用戶接口跨多個平臺的可移植性；同時經過簡化服務器組件，改善了系統的可伸縮性。
(2)無狀態：通訊在本質上是無狀態的，改善了可見性、可靠性、可伸縮性.
(3)緩存：改善了網絡效率減小一系列交互的平均延遲時間，來提升效率、可伸縮性和用戶可覺察的性能。
(4)統一接口：REST架構風格區別於其餘基於網絡的架構風格的核心特徵是，它強調組件之間要有一個統一的接口。

72.Tomcat，Apache，JBoss的區別

Apache:HTTP服務器(WEB服務器)，相似IIS，能夠用於創建虛擬站點，編譯處理靜態頁面，能夠支持SSL技術，支持多個虛擬主機等功能。
Tomcat:Servlet容器，用於解析jsp，Servlet的Servlet容器，是高效，輕量級的容器。缺點是不支持EJB，只能用於java應用。
Jboss:應用服務器，運行EJB的J2EE應用服務器，遵循J2EE規範，可以提供更多平臺的支持和更多集成功能，如數據庫鏈接，JCA等，其對Servlet的支持是經過集成其餘Servlet容器來實現的，如tomcat和jetty。

73.memcached和redis的區別

(1)性能對比：因爲Redis只使用單核，而Memcached能夠使用多核，因此平均每個核上Redis在存儲小數據時比Memcached性能更高。而在100k以上的數據中，Memcached性能要高於Redis，雖然Redis最近也在存儲大數據的性能上進行優化，可是比起Memcached，仍是稍有遜色。
(2)內存使用效率對比：使用簡單的key-value存儲的話，Memcached的內存利用率更高，而若是Redis採用hash結構來作key-value存儲，因爲其組合式的壓縮，其內存利用率會高於Memcached。
(3)Redis支持服務器端的數據操做：Redis相比Memcached來講，擁有更多的數據結構和並支持更豐富的數據操做，一般在Memcached裏，你須要將數據拿到客戶端來進行相似的修改再set回去。這大大增長了網絡IO的次數和數據體積。在Redis中，這些複雜的操做一般和通常的GET/SET同樣高效。因此，若是須要緩存可以支持更復雜的結構和操做，那麼Redis會是不錯的選擇。

74.如何理解分佈式鎖

參考文章：
blog.csdn.net/zheng0518/a…
blog.csdn.net/nicewuranra…

75.你知道的開源協議有哪些

常見的開源協議有GPL、LGPL、BSD、Apache Licence
vesion 2.0、MIT，詳細內容參考文章:
blog.jobbole.com/44175/、http…

76.json和xml區別

XML:
(1)應用普遍，可擴展性強，被普遍應用各類場合；
(2)讀取、解析沒有JSON快；
(3)可讀性強，可描述複雜結構。
JSON:
(1)結構簡單，都是鍵值對；
(2)讀取、解析速度快，不少語言支持；
(3)傳輸數據量小，傳輸速率大大提升；
(4)描述複雜結構能力較弱。

77.設計模式

參考文章：www.cnblogs.com/beijiguangy…

78.設計模式的六大原則

參考文章www.uml.org.cn/sjms/201211…

79.用一個設計模式寫一段代碼或畫出一個設計模式的UML

參考文章www.cnblogs.com/beijiguangy…

80.高內聚，低耦合方面的理解

參考文章my.oschina.net/heweipo/blo…

81.深度優先和廣度優先算法

推薦看書籍複習！可參考文章：
blog.163.com/zhoumhan_03…
blog.163.com/zhoumhan_03…
blog.csdn.net/andyelvis/a…
driftcloudy.iteye.com/blog/782873

82.排序算法及對應的時間複雜度和空間複雜度

推薦看書籍複習！可參考文章：
www.cnblogs.com/liuling/p/2…
blog.csdn.net/cyuyanenen/…
blog.csdn.net/whuslei/art…

83.排序算法編碼實現

參考www.cnblogs.com/liuling/p/2…

84.查找算法

參考sanwen8.cn/p/142Wbu5.h…

85.B+樹

參考www.cnblogs.com/syxchina/ar…

86.KMP算法

推薦閱讀數據複習！參考www.cnblogs.com/c-cloud/p/3…

87.hash算法及經常使用的hash算法

參考www.360doc.com/content/13/…

88.如何判斷一個單鏈表是否有環

參考文章：
www.jianshu.com/p/0e28d3160…
my.oschina.net/u/2391658/b…

89.隊列、棧、鏈表、樹、堆、圖

推薦閱讀數據複習！

90.linux經常使用命令

參考www.jianshu.com/p/03cfc1a72…

91.如何查看內存使用狀況

參考blog.csdn.net/windrui/art…

92.Linux下如何進行進程調度

推薦閱讀書籍複習，參考文章：
www.cnblogs.com/zhaoyl/arch…
blog.csdn.net/rainharder/…

93.產生死鎖的必要條件

參考blog.sina.com.cn/s/blog_5e36…

94.死鎖預防

參考blog.sina.com.cn/s/blog_5e36…

95.數據庫範式

參考www.360doc.com/content/12/…

96.數據庫事務隔離級別

參考blog.csdn.net/fg2006/arti…

97.數據庫鏈接池的原理

參考blog.csdn.net/shuaihj/art…

98.樂觀鎖和悲觀鎖

參考www.open-open.com/lib/view/op…

99.如何實現不一樣數據庫的數據查詢分頁

參考blog.csdn.net/yztezhl/art…

100.SQL注入的原理，如何預防

參考www.aliyun.com/zixun/conte…

101.數據庫索引的實現(B+樹介紹、和B樹、R樹區別)

參考文章：
blog.csdn.net/kennyrose/a…
www.xuebuyuan.com/2216918.htm…

102.SQL性能優化

參考文章：
database.51cto.com/art/200904/…
www.cnblogs.com/rootq/archi…

103.數據庫索引的優缺點以及何時數據庫索引失效

參考文章：
www.cnblogs.com/mxmbk/artic…
www.cnblogs.com/simplefrog/…
www.open-open.com/lib/view/op…
blog.csdn.net/colin_liu20…
www.cnblogs.com/hongfei/arc…

104.Redis的數據類型

參考blog.csdn.net/hechurui/ar…

105.OSI七層模型以及TCP/IP四層模型

參考文章：
blog.csdn.net/sprintfwate…
www.cnblogs.com/commanderzh…
blog.csdn.net/superjunjin…

106.HTTP和HTTPS區別

參考：
blog.csdn.net/mingli19861…
www.mahaixiang.cn/internet/12…

107.HTTP報文內容

參考文章：
yq.aliyun.com/articles/44…
www.cnblogs.com/klguang/p/4…
my.oschina.net/orgsky/blog…

108.get提交和post提交的區別

參考文章：
www.cnblogs.com/hyddd/archi…
www.jellythink.com/archives/80…

109.get提交是否有字節限制，若是有是在哪限制的

參考www.jellythink.com/archives/80…

110.TCP的三次握手和四次揮手

閱讀www.jianshu.com/p/f7d1010fa…

111.session和cookie的區別

參考www.cnblogs.com/shiyangxt/a…

112.HTTP請求中Session實現原理

參考blog.csdn.net/zhq426/arti…

113.redirect與forward區別

參考www.cnblogs.com/wxgblogs/p/…

114.TCP和UDP區別

參考www.cnblogs.com/bizhu/archi…

115.DDos攻擊及預防

參考文章：
blog.csdn.net/huwei2003/a…
www.leiphone.com/news/201509

最近 5 年 133 個 Java 面試問題列表

ava 面試隨着時間的改變而改變。在過去的日子裏，當你知道 String 和 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 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）什麼是線程局部變量？(答案)
線程局部變量是侷限於線程內部的變量，屬於線程自身全部，不在多個線程間共享。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 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 語句。
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 緩存？(答案<)< p="">

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 工具更多的不一樣之處請參見答案。

這就是全部的面試題，如此之多，是否是？我能夠保證，若是你能回答列表中的全部問題，你就能夠很輕鬆的應付任何核心 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 面試問題列表。