來自：江湖人稱小白哥

https://blog.csdn.net/dd864140130/article/details/55833087

今天要談的主題是關於求職.求職是在每個技術人員的生涯中都要經歷多次,對於我們大部分人而言,在進入自己心儀的公司之前少不了準備工作,有一份全面細緻面試題將幫助我們減少許多麻煩.在跳槽季來臨之前,特地做這個系列的文章,一方面幫助自己鞏固下基礎,另一方面也希望幫助想要換工作的朋友.

相關概念

面向物件的三個特徵

封裝,繼承,多型.這個應該是人人皆知.有時候也會加上抽象.

多型的好處

允許不同類物件對同一訊息做出響應,即同一訊息可以根據傳送物件的不同而採用多種不同的行為方式(傳送訊息就是函式呼叫).主要有以下優點:

1. 可替換性:多型對已存在程式碼具有可替換性.

2. 可擴充性:增加新的子類不影響已經存在的類結構.

3. 介面性:多型是超類透過方法簽名,向子類提供一個公共介面,由子類來完善或者重寫它來實現的.

4. 靈活性.

5. 簡化性.

程式碼中如何實現多型

實現多型主要有以下三種方式: 
1. 介面實現 
2. 繼承父類重寫方法 
3. 同一類中進行方法多載

虛擬機器是如何實現多型的

動態系結技術(dynamic binding),執行期間判斷所取用物件的實際型別,根據實際型別呼叫對應的方法.

介面的意義

介面的意義用三個詞就可以概括:規範,擴充套件,回呼.

抽象類的意義

抽象類的意義可以用三句話來概括:

1. 為其他子類提供一個公共的型別

2. 封裝子類中重覆定義的內容

3. 定義抽象方法,子類雖然有不同的實現,但是定義時一致的

介面和抽象類的區別

父類的靜態方法能否被子類重寫

不能.重寫只適用於實體方法,不能用於靜態方法,而子類當中含有和父類相同簽名的靜態方法,我們一般稱之為隱藏.

什麼是不可變物件

不可變物件指物件一旦被建立，狀態就不能再改變。任何修改都會建立一個新的物件，如 String、Integer及其它包裝類。

靜態變數和實體變數的區別?

靜態變數儲存在方法區,屬於類所有.實體變數儲存在堆當中,其取用存在當前執行緒棧.

能否建立一個包含可變物件的不可變物件?

當然可以建立一個包含可變物件的不可變物件的，你只需要謹慎一點，不要共享可變物件的取用就可以了，如果需要變化時，就傳回原物件的一個複製。最常見的例子就是物件中包含一個日期物件的取用.

java 建立物件的幾種方式

1. 採用new

2. 透過反射

3. 採用clone

4. 透過序列化機制

前2者都需要顯式地呼叫構造方法. 造成耦合性最高的恰好是第一種,因此你發現無論什麼框架,只要涉及到解耦必先減少new的使用.

switch中能否使用string做引數

在idk 1.7之前,switch只能支援byte,short,char,int或者其對應的封裝類以及Enum型別。從idk 1.7之後switch開始支援String.

switch能否作用在byte,long上?

可以用在byte上,但是不能用在long上.

String s1=”ab”,String s2=”a”+”b”,String s3=”a”,String s4=”b”,s5=s3+s4請問s5==s2傳回什麼?

傳回false.在編譯過程中,編譯器會將s2直接最佳化為”ab”,會將其放置在常量池當中,s5則是被建立在堆區,相當於s5=new String(“ab”);

你對String物件的intern()熟悉麼?

intern()方法會首先從常量池中查詢是否存在該常量值,如果常量池中不存在則現在常量池中建立,如果已經存在則直接傳回. 
比如 
String s1=”aa”; 
String s2=s1.intern(); 
System.out.print(s1==s2);//傳回true

Object中有哪些公共方法?

1. equals()

2. clone()

3. getClass()

4. notify(),notifyAll(),wait()

5. toString

java當中的四種取用

強取用,軟取用,弱取用,虛取用.不同的取用型別主要體現在GC上:

1. 強取用：如果一個物件具有強取用，它就不會被垃圾回收器回收。即使當前記憶體空間不足，JVM也不會回收它，而是丟擲 OutOfMemoryError 錯誤，使程式異常終止。如果想中斷強取用和某個物件之間的關聯，可以顯式地將取用賦值為null，這樣一來的話，JVM在合適的時間就會回收該物件

2. 軟取用：在使用軟取用時，如果記憶體的空間足夠，軟取用就能繼續被使用，而不會被垃圾回收器回收，只有在記憶體不足時，軟取用才會被垃圾回收器回收。

3. 弱取用：具有弱取用的物件擁有的生命週期更短暫。因為當 JVM 進行垃圾回收，一旦發現弱取用物件，無論當前記憶體空間是否充足，都會將弱取用回收。不過由於垃圾回收器是一個優先順序較低的執行緒，所以並不一定能迅速發現弱取用物件

4. 虛取用：顧名思義，就是形同虛設，如果一個物件僅持有虛取用，那麼它相當於沒有取用，在任何時候都可能被垃圾回收器回收。

更多瞭解參見深入物件取用：

http://blog.csdn.net/dd864140130/article/details/49885811

WeakReference與SoftReference的區別?

這點在四種取用型別中已經做瞭解釋,這裡簡單說明一下即可: 
雖然 WeakReference 與 SoftReference 都有利於提高 GC 和 記憶體的效率，但是 WeakReference ，一旦失去最後一個強取用，就會被 GC 回收，而軟取用雖然不能阻止被回收，但是可以延遲到 JVM 記憶體不足的時候。

為什麼要有不同的取用型別

不像C語言,我們可以控制記憶體的申請和釋放,在Java中有時候我們需要適當的控制物件被回收的時機,因此就誕生了不同的取用型別,可以說不同的取用型別實則是對GC回收時機不可控的妥協.有以下幾個使用場景可以充分的說明:

1. 利用軟取用和弱取用解決OOM問題：用一個HashMap來儲存圖片的路徑和相應圖片物件關聯的軟取用之間的對映關係，在記憶體不足時，JVM會自動回收這些快取圖片物件所佔用的空間，從而有效地避免了OOM的問題.

2. 透過軟取用實現Java物件的高速快取:比如我們建立了一Person的類，如果每次需要查詢一個人的資訊,哪怕是幾秒中之前剛剛查詢過的，都要重新構建一個實體，這將引起大量Person物件的消耗,並且由於這些物件的生命週期相對較短,會引起多次GC影響效能。此時,透過軟取用和 HashMap 的結合可以構建高速快取,提供效能.

java中==和eqauls()的區別,equals()和`hashcode的區別

==是運運算元,用於比較兩個變數是否相等,而equals是Object類的方法,用於比較兩個物件是否相等.預設Object類的equals方法是比較兩個物件的地址,此時和==的結果一樣.換句話說:基本型別比較用==,比較的是他們的值.預設下,物件用==比較時,比較的是記憶體地址,如果需要比較物件內容,需要重寫equal方法

equals()和hashcode()的聯絡

hashCode()是Object類的一個方法,傳回一個雜湊值.如果兩個物件根據equal()方法比較相等,那麼呼叫這兩個物件中任意一個物件的hashCode()方法必須產生相同的雜湊值. 
如果兩個物件根據eqaul()方法比較不相等,那麼產生的雜湊值不一定相等(碰撞的情況下還是會相等的.)

a.hashCode()有什麼用?與a.equals(b)有什麼關係

hashCode() 方法是相應物件整型的 hash 值。它常用於基於 hash 的集合類，如 Hashtable、HashMap、LinkedHashMap等等。它與 equals() 方法關係特別緊密。根據 Java 規範，使用 equal() 方法來判斷兩個相等的物件，必須具有相同的 hashcode。

將物件放入到集合中時,首先判斷要放入物件的hashcode是否已經在集合中存在,不存在則直接放入集合.如果hashcode相等,然後透過equal()方法判斷要放入物件與集合中的任意物件是否相等:如果equal()判斷不相等,直接將該元素放入集合中,否則不放入.

有沒有可能兩個不相等的物件有相同的hashcode

有可能，兩個不相等的物件可能會有相同的 hashcode 值，這就是為什麼在 hashmap 中會有衝突。如果兩個物件相等，必須有相同的hashcode 值，反之不成立.

可以在hashcode中使用隨機數字嗎?

不行，因為同一物件的 hashcode 值必須是相同的

a==b與a.equals(b)有什麼區別

如果a 和b 都是物件，則 a==b 是比較兩個物件的取用，只有當 a 和 b 指向的是堆中的同一個物件才會傳回 true，而 a.equals(b) 是進行邏輯比較，所以通常需要重寫該方法來提供邏輯一致性的比較。例如，String 類重寫 equals() 方法，所以可以用於兩個不同物件，但是包含的字母相同的比較。

3*0.1==0.3傳回值是什麼

false，因為有些浮點數不能完全精確的表示出來。

a=a+b與a+=b有什麼區別嗎?

+=運運算元會進行隱式自動型別轉換,此處a+=b隱式的將加操作的結果型別強制轉換為持有結果的型別,而a=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 就會編譯出錯）

short s1= 1; s1 = s1 + 1; 該段程式碼是否有錯,有的話怎麼改？

有錯誤,short型別在進行運算時會自動提升為int型別,也就是說s1+1的運算結果是int型別.

short s1= 1; s1 += 1; 該段程式碼是否有錯,有的話怎麼改？

+=運運算元會自動對右邊的運算式結果強轉匹配左邊的資料型別,所以沒錯.

& 和 &&的區別

首先記住&是位操作,而&&是邏輯運運算元.另外需要記住邏輯運運算元具有短路特性,而&不具備短路特性.

public class Test{
    static String name;

    public static void main(String[] args){
        if(name!=null&userName.;equals("")){
            System.out.println("ok");
        }else{
            System.out.println("erro");
        }
    }
}

以上程式碼將會丟擲空指標異常.

一個.java檔案內部可以有類?(非內部類)

只能有一個public公共類,但是可以有多個default修飾的類.

如何正確的退出多層巢狀迴圈.

1. 使用標號和break;

2. 透過在外層迴圈中新增識別符號

內部類的作用

內部類可以有多個實體,每個實體都有自己的狀態資訊,並且與其他外圍物件的資訊相互獨立.在單個外圍類當中,可以讓多個內部類以不同的方式實現同一介面,或者繼承同一個類.建立內部類物件的時刻不依賴於外部類物件的建立.內部類並沒有令人疑惑的”is-a”關係,它就像是一個獨立的物體.

內部類提供了更好的封裝,除了該外圍類,其他類都不能訪問

final,finalize和finally的不同之處

final 是一個修飾符，可以修飾變數、方法和類。如果 final 修飾變數，意味著該變數的值在初始化後不能被改變。finalize 方法是在物件被回收之前呼叫的方法，給物件自己最後一個複活的機會，但是什麼時候呼叫 finalize 沒有保證。finally 是一個關鍵字，與 try 和 catch 一起用於異常的處理。finally 塊一定會被執行，無論在 try 塊中是否有發生異常。

clone()是哪個類的方法?

java.lang.Cloneable 是一個標示性介面，不包含任何方法，clone 方法在 object 類中定義。並且需要知道 clone() 方法是一個本地方法，這意味著它是由 c 或 c++ 或 其他本地語言實現的。

深複製和淺複製的區別是什麼?

淺複製：被覆制物件的所有變數都含有與原來的物件相同的值，而所有的對其他物件的取用仍然指向原來的物件。換言之，淺複製僅僅複製所考慮的物件，而不複製它所取用的物件。

深複製：被覆制物件的所有變數都含有與原來的物件相同的值，而那些取用其他物件的變數將指向被覆制過的新物件，而不再是原有的那些被取用的物件。換言之，深複製把要複製的物件所取用的物件都複製了一遍。

static都有哪些用法?

幾乎所有的人都知道static關鍵字這兩個基本的用法:靜態變數和靜態方法.也就是被static所修飾的變數/方法都屬於類的靜態資源,類實體所共享.

除了靜態變數和靜態方法之外,static也用於靜態塊,多用於初始化操作:

public calss PreCache{
    static{
        //執行相關操作
    }
}

此外static也多用於修飾內部類,此時稱之為靜態內部類.

最後一種用法就是靜態導包,即import static.import static是在JDK 1.5之後引入的新特性,可以用來指定匯入某個類中的靜態資源,並且不需要使用類名.資源名,可以直接使用資源名,比如:

import static java.lang.Math.*;

public class Test{

    public static void main(String[] args){
        //System.out.println(Math.sin(20));傳統做法
        System.out.println(sin(20));
    }
}

final有哪些用法

final也是很多面試喜歡問的地方,能回答下以下三點就不錯了: 
1.被final修飾的類不可以被繼承 
2.被final修飾的方法不可以被重寫 
3.被final修飾的變數不可以被改變.如果修飾取用,那麼表示取用不可變,取用指向的內容可變. 
4.被final修飾的方法,JVM會嘗試將其行內,以提高執行效率 
5.被final修飾的常量,在編譯階段會存入常量池中.

回答出編譯器對final域要遵守的兩個重排序規則更好: 
1.在建構式內對一個final域的寫入,與隨後把這個被構造物件的取用賦值給一個取用變數,這兩個操作之間不能重排序. 
2.初次讀一個包含final域的物件的取用,與隨後初次讀這個final域,這兩個操作之間不能重排序.

資料型別相關

java中int char,long各佔多少位元組?

64位的JVM當中,int的長度是多少?

Java 中，int 型別變數的長度是一個固定值，與平臺無關，都是 32 位。意思就是說，在 32 位 和 64 位 的Java 虛擬機器中，int 型別的長度是相同的。

int和Integer的區別

Integer是int的包裝型別,在拆箱和裝箱中,二者自動轉換.int是基本型別，直接存數值，而integer是物件，用一個取用指向這個物件.

int 和Integer誰佔用的記憶體更多?

Integer 物件會佔用更多的記憶體。Integer是一個物件，需要儲存物件的元資料。但是 int 是一個原始型別的資料，所以佔用的空間更少。

String,StringBuffer和StringBuilder區別

String是字串常量,final修飾;StringBuffer字串變數(執行緒安全); 
StringBuilder 字串變數(執行緒不安全).

String和StringBuffer

String和StringBuffer主要區別是效能:String是不可變物件,每次對String型別進行操作都等同於產生了一個新的String物件,然後指向新的String物件.所以儘量不在對String進行大量的拼接操作,否則會產生很多臨時物件,導致GC開始工作,影響系統效能.

StringBuffer是對物件本身操作,而不是產生新的物件,因此在有大量拼接的情況下,我們建議使用StringBuffer.

但是需要註意現在JVM會對String拼接做一定的最佳化: 
String s=“This is only ”+”simple”+”test”會被虛擬機器直接最佳化成String s=“This is only simple test”,此時就不存在拼接過程.

StringBuffer和StringBuilder

StringBuffer是執行緒安全的可變字串,其內部實現是可變陣列.StringBuilder是jdk 1.5新增的,其功能和StringBuffer類似,但是非執行緒安全.因此,在沒有多執行緒問題的前提下,使用StringBuilder會取得更好的效能.

什麼是編譯器常量?使用它有什麼風險?

公共靜態不可變（public static final ）變數也就是我們所說的編譯期常量，這裡的 public 可選的。實際上這些變數在編譯時會被替換掉，因為編譯器知道這些變數的值，並且知道這些變數在執行時不能改變。這種方式存在的一個問題是你使用了一個內部的或第三方庫中的公有編譯時常量，但是這個值後面被其他人改變了，但是你的客戶端仍然在使用老的值，甚至你已經部署了一個新的jar。為了避免這種情況，當你在更新依賴 JAR 檔案時，確保重新編譯你的程式。

java當中使用什麼型別表示價格比較好?

如果不是特別關心記憶體和效能的話，使用BigDecimal，否則使用預定義精度的 double 型別。

如何將byte轉為String

可以使用 String 接收 byte[] 引數的建構式來進行轉換，需要註意的點是要使用的正確的編碼，否則會使用平臺預設編碼，這個編碼可能跟原來的編碼相同，也可能不同。

可以將int強轉為byte型別麼?會產生什麼問題?

我們可以做強制轉換，但是Java中int是32位的而byte是8 位的，所以,如果強制轉化int型別的高24位將會被丟棄，byte 型別的範圍是從-128到128

關於垃圾回收

你知道哪些垃圾回收演演算法?

垃圾回收從理論上非常容易理解,具體的方法有以下幾種: 
1. 標記-清除 
2. 標記-複製 
3. 標記-整理 
4. 分代回收 
更詳細的內容參見深入理解垃圾回收演演算法：

http://blog.csdn.net/dd864140130/article/details/50084471

如何判斷一個物件是否應該被回收

這就是所謂的物件存活性判斷,常用的方法有兩種:1.取用計數法;2:物件可達性分析.由於取用計數法存在互相取用導致無法進行GC的問題,所以目前JVM虛擬機器多使用物件可達性分析演演算法.

簡單的解釋一下垃圾回收

Java 垃圾回收機制最基本的做法是分代回收。記憶體中的區域被劃分成不同的世代，物件根據其存活的時間被儲存在對應世代的區域中。一般的實現是劃分成3個世代：年輕、年老和永久。記憶體的分配是發生在年輕世代中的。當一個物件存活時間足夠長的時候，它就會被覆制到年老世代中。對於不同的世代可以使用不同的垃圾回收演演算法。進行世代劃分的出發點是對應用中物件存活時間進行研究之後得出的統計規律。一般來說，一個應用中的大部分物件的存活時間都很短。比如區域性變數的存活時間就只在方法的執行過程中。基於這一點，對於年輕世代的垃圾回收演演算法就可以很有針對性.

呼叫System.gc()會發生什麼?

通知GC開始工作,但是GC真正開始的時間不確定.

行程,執行緒相關

說說行程,執行緒,協程之間的區別

簡而言之,行程是程式執行和資源分配的基本單位,一個程式至少有一個行程,一個行程至少有一個執行緒.行程在執行過程中擁有獨立的記憶體單元,而多個執行緒共享記憶體資源,減少切換次數,從而效率更高.執行緒是行程的一個物體,是cpu排程和分派的基本單位,是比程式更小的能獨立執行的基本單位.同一行程中的多個執行緒之間可以併發執行.

你瞭解守護執行緒嗎?它和非守護執行緒有什麼區別

程式執行完畢,jvm會等待非守護執行緒完成後關閉,但是jvm不會等待守護執行緒.守護執行緒最典型的例子就是GC執行緒

什麼是多執行緒背景關係切換

多執行緒的背景關係切換是指CPU控制權由一個已經正在執行的執行緒切換到另外一個就緒並等待獲取CPU執行權的執行緒的過程。

建立兩種執行緒的方式?他們有什麼區別?

透過實現java.lang.Runnable或者透過擴充套件java.lang.Thread類.相比擴充套件Thread,實現Runnable介面可能更優.原因有二:

1. Java不支援多繼承.因此擴充套件Thread類就代表這個子類不能擴充套件其他類.而實現Runnable介面的類還可能擴充套件另一個類.

2. 類可能只要求可執行即可,因此繼承整個Thread類的開銷過大.

Thread類中的start()和run()方法有什麼區別?

start()方法被用來啟動新建立的執行緒，而且start()內部呼叫了run()方法，這和直接呼叫run()方法的效果不一樣。當你呼叫run()方法的時候，只會是在原來的執行緒中呼叫，沒有新的執行緒啟動，start()方法才會啟動新執行緒。

怎麼檢測一個執行緒是否持有物件監視器

Thread類提供了一個holdsLock(Object obj)方法，當且僅當物件obj的監視器被某條執行緒持有的時候才會傳回true，註意這是一個static方法，這意味著”某條執行緒”指的是當前執行緒。

Runnable和Callable的區別

Runnable介面中的run()方法的傳回值是void，它做的事情只是純粹地去執行run()方法中的程式碼而已；Callable介面中的call()方法是有傳回值的，是一個泛型，和Future、FutureTask配合可以用來獲取非同步執行的結果。 
這其實是很有用的一個特性，因為多執行緒相比單執行緒更難、更複雜的一個重要原因就是因為多執行緒充滿著未知性，某條執行緒是否執行了？某條執行緒執行了多久？某條執行緒執行的時候我們期望的資料是否已經賦值完畢？無法得知，我們能做的只是等待這條多執行緒的任務執行完畢而已。而Callable+Future/FutureTask卻可以方便獲取多執行緒執行的結果，可以在等待時間太長沒獲取到需要的資料的情況下取消該執行緒的任務

什麼導致執行緒阻塞

阻塞指的是暫停一個執行緒的執行以等待某個條件發生（如某資源就緒），學過作業系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支援阻塞，下麵讓我們逐一分析。

wait(),notify()和suspend(),resume()之間的區別

初看起來它們與 suspend() 和 resume() 方法對沒有什麼分別，但是事實上它們是截然不同的。區別的核心在於，前面敘述的所有方法，阻塞時都不會釋放佔用的鎖（如果佔用了的話），而這一對方法則相反。上述的核心區別導致了一系列的細節上的區別。

首先，前面敘述的所有方法都隸屬於 Thread 類，但是這一對卻直接隸屬於 Object 類，也就是說，所有物件都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放佔用的鎖，而鎖是任何物件都具有的，呼叫任意物件的 wait() 方法導致執行緒阻塞，並且該物件上的鎖被釋放。而呼叫 任意物件的notify()方法則導致從呼叫該物件的 wait() 方法而阻塞的執行緒中隨機選擇的一個解除阻塞（但要等到獲得鎖後才真正可執行）。

其次，前面敘述的所有方法都可在任何位置呼叫，但是這一對方法卻必須在 synchronized 方法或塊中呼叫，理由也很簡單，只有在synchronized 方法或塊中當前執行緒才佔有鎖，才有鎖可以釋放。同樣的道理，呼叫這一對方法的物件上的鎖必須為當前執行緒所擁有，這樣才有鎖可以釋放。因此，這一對方法呼叫必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖物件就是呼叫這一對方法的物件。若不滿足這一條件，則程式雖然仍能編譯，但在執行時會出現IllegalMonitorStateException 異常。

wait() 和 notify() 方法的上述特性決定了它們經常和synchronized關鍵字一起使用，將它們和作業系統行程間通訊機製作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似於作業系統原語的功能，它們的執行不會受到多執行緒機制的幹擾，而這一對方法則相當於 block 和wakeup 原語（這一對方法均宣告為 synchronized）。它們的結合使得我們可以實現作業系統上一系列精妙的行程間通訊的演演算法（如訊號量演演算法），並用於解決各種複雜的執行緒間通訊問題。

關於 wait() 和 notify() 方法最後再說明兩點： 
第一：呼叫 notify() 方法導致解除阻塞的執行緒是從因呼叫該物件的 wait() 方法而阻塞的執行緒中隨機選取的，我們無法預料哪一個執行緒將會被選擇，所以程式設計時要特別小心，避免因這種不確定性而產生問題。

第二：除了 notify()，還有一個方法 notifyAll() 也可起到類似作用，唯一的區別在於，呼叫 notifyAll() 方法將把因呼叫該物件的 wait() 方法而阻塞的所有執行緒一次性全部解除阻塞。當然，只有獲得鎖的那一個執行緒才能進入可執行狀態。

談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend() 方法和不指定超時期限的 wait() 方法的呼叫都可能產生死鎖。遺憾的是，Java 並不在語言級別上支援死鎖的避免，我們在程式設計中必須小心地避免死鎖。

以上我們對 Java 中實現執行緒阻塞的各種方法作了一番分析，我們重點分析了 wait() 和 notify() 方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。

產生死鎖的條件

1.互斥條件：一個資源每次只能被一個行程使用。 
2.請求與保持條件：一個行程因請求資源而阻塞時，對已獲得的資源保持不放。 
3.不剝奪條件:行程已獲得的資源，在末使用完之前，不能強行剝奪。 
4.迴圈等待條件:若干行程之間形成一種頭尾相接的迴圈等待資源關係。

為什麼wait()方法和notify()/notifyAll()方法要在同步塊中被呼叫

這是JDK強制的，wait()方法和notify()/notifyAll()方法在呼叫前都必須先獲得物件的鎖

wait()方法和notify()/notifyAll()方法在放棄物件監視器時有什麼區別

wait()方法和notify()/notifyAll()方法在放棄物件監視器的時候的區別在於：wait()方法立即釋放物件監視器，notify()/notifyAll()方法則會等待執行緒剩餘程式碼執行完畢才會放棄物件監視器。

wait()與sleep()的區別

關於這兩者已經在上面進行詳細的說明,這裡就做個概括好了:

• sleep()來自Thread類，和wait()來自Object類.呼叫sleep()方法的過程中，執行緒不會釋放物件鎖。而 呼叫 wait 方法執行緒會釋放物件鎖

• sleep()睡眠後不出讓系統資源，wait讓其他執行緒可以佔用CPU

• sleep(milliseconds)需要指定一個睡眠時間，時間一到會自動喚醒.而wait()需要配合notify()或者notifyAll()使用

為什麼wait,nofity和nofityAll這些方法不放在Thread類當中

一個很明顯的原因是JAVA提供的鎖是物件級的而不是執行緒級的，每個物件都有鎖，透過執行緒獲得。如果執行緒需要等待某些鎖那麼呼叫物件中的wait()方法就有意義了。如果wait()方法定義在Thread類中，執行緒正在等待的是哪個鎖就不明顯了。簡單的說，由於wait，notify和notifyAll都是鎖級別的操作，所以把他們定義在Object類中因為鎖屬於物件。

怎麼喚醒一個阻塞的執行緒

如果執行緒是因為呼叫了wait()、sleep()或者join()方法而導致的阻塞，可以中斷執行緒，並且透過丟擲InterruptedException來喚醒它；如果執行緒遇到了IO阻塞，無能為力，因為IO是作業系統實現的，Java程式碼並沒有辦法直接接觸到作業系統。

什麼是多執行緒的背景關係切換

多執行緒的背景關係切換是指CPU控制權由一個已經正在執行的執行緒切換到另外一個就緒並等待獲取CPU執行權的執行緒的過程。

synchronized和ReentrantLock的區別

synchronized是和if、else、for、while一樣的關鍵字，ReentrantLock是類，這是二者的本質區別。既然ReentrantLock是類，那麼它就提供了比synchronized更多更靈活的特性，可以被繼承、可以有方法、可以有各種各樣的類變數，ReentrantLock比synchronized的擴充套件性體現在幾點上： 
（1）ReentrantLock可以對獲取鎖的等待時間進行設定，這樣就避免了死鎖 
（2）ReentrantLock可以獲取各種鎖的資訊 
（3）ReentrantLock可以靈活地實現多路通知 
另外，二者的鎖機制其實也是不一樣的:ReentrantLock底層呼叫的是Unsafe的park方法加鎖，synchronized操作的應該是物件頭中mark word.

FutureTask是什麼

這個其實前面有提到過，FutureTask表示一個非同步運算的任務。FutureTask裡面可以傳入一個Callable的具體實現類，可以對這個非同步運算的任務的結果進行等待獲取、判斷是否已經完成、取消任務等操作。當然，由於FutureTask也是Runnable介面的實現類，所以FutureTask也可以放入執行緒池中。

一個執行緒如果出現了執行時異常怎麼辦?

如果這個異常沒有被捕獲的話，這個執行緒就停止執行了。另外重要的一點是：如果這個執行緒持有某個某個物件的監視器，那麼這個物件監視器會被立即釋放

Java當中有哪幾種鎖

1. 自旋鎖: 自旋鎖在JDK1.6之後就預設開啟了。基於之前的觀察，共享資料的鎖定狀態只會持續很短的時間，為了這一小段時間而去掛起和恢復執行緒有點浪費，所以這裡就做了一個處理，讓後面請求鎖的那個執行緒在稍等一會，但是不放棄處理器的執行時間，看看持有鎖的執行緒能否快速釋放。為了讓執行緒等待，所以需要讓執行緒執行一個忙迴圈也就是自旋操作。在jdk6之後，引入了自適應的自旋鎖，也就是等待的時間不再固定了，而是由上一次在同一個鎖上的自旋時間及鎖的擁有者狀態來決定

2. 偏向鎖: 在JDK1.之後引入的一項鎖最佳化，目的是消除資料在無競爭情況下的同步原語。進一步提升程式的執行效能。 偏向鎖就是偏心的偏，意思是這個鎖會偏向第一個獲得他的執行緒，如果接下來的執行過程中，改鎖沒有被其他執行緒獲取，則持有偏向鎖的執行緒將永遠不需要再進行同步。偏向鎖可以提高帶有同步但無競爭的程式效能，也就是說他並不一定總是對程式執行有利，如果程式中大多數的鎖都是被多個不同的執行緒訪問，那偏向樣式就是多餘的，在具體問題具體分析的前提下，可以考慮是否使用偏向鎖。

3. 輕量級鎖: 為了減少獲得鎖和釋放鎖所帶來的效能消耗，引入了“偏向鎖”和“輕量級鎖”，所以在Java SE1.6裡鎖一共有四種狀態，無鎖狀態，偏向鎖狀態，輕量級鎖狀態和重量級鎖狀態，它會隨著競爭情況逐漸升級。鎖可以升級但不能降級，意味著偏向鎖升級成輕量級鎖後不能降級成偏向鎖

如何在兩個執行緒間共享資料

透過在執行緒之間共享物件就可以了，然後透過wait/notify/notifyAll、await/signal/signalAll進行喚起和等待，比方說阻塞佇列BlockingQueue就是為執行緒之間共享資料而設計的

如何正確的使用wait()?使用if還是while?

wait() 方法應該在迴圈呼叫，因為當執行緒獲取到 CPU 開始執行的時候，其他條件可能還沒有滿足，所以在處理前，迴圈檢測條件是否滿足會更好。下麵是一段標準的使用 wait 和 notify 方法的程式碼：

synchronized (obj) {
    while (condition does not hold)
      obj.wait(); // (Releases lock, and reacquires on wakeup)
      ... // Perform action appropriate to condition
 }

什麼是執行緒區域性變數ThreadLocal

執行緒區域性變數是侷限於執行緒內部的變數，屬於執行緒自身所有，不在多個執行緒間共享。Java提供ThreadLocal類來支援執行緒區域性變數，是一種實現執行緒安全的方式。但是在管理環境下（如 web 伺服器）使用執行緒區域性變數的時候要特別小心，在這種情況下，工作執行緒的生命週期比任何應用變數的生命週期都要長。任何執行緒區域性變數一旦在工作完成後沒有釋放，Java 應用就存在記憶體洩露的風險。

ThreadLoal的作用是什麼?

簡單說ThreadLocal就是一種以空間換時間的做法在每個Thread裡面維護了一個ThreadLocal.ThreadLocalMap把資料進行隔離，資料不共享，自然就沒有執行緒安全方面的問題了.

生產者消費者模型的作用是什麼?

（1）透過平衡生產者的生產能力和消費者的消費能力來提升整個系統的執行效率，這是生產者消費者模型最重要的作用 
（2）解耦，這是生產者消費者模型附帶的作用，解耦意味著生產者和消費者之間的聯絡少，聯絡越少越可以獨自發展而不需要收到相互的制約

寫一個生產者-消費者佇列

可以透過阻塞佇列實現,也可以透過wait-notify來實現.

使用阻塞佇列來實現

//消費者
public class Producer implements Runnable{
    private final BlockingQueue queue;

    public Producer(BlockingQueue q){
        this.queue=q;
    }

    @Override
    public void run() {
        try {
            while (true){
                Thread.sleep(1000);//模擬耗時
                queue.put(produce());
            }
        }catch (InterruptedException e){

        }
    }

    private int produce() {
        int n=new Random().nextInt(10000);
        System.out.println("Thread:" + Thread.currentThread().getId() + " produce:" + n);
        return n;
    }
}
//消費者
public class Consumer implements Runnable {
    private final BlockingQueue queue;

    public Consumer(BlockingQueue q){
        this.queue=q;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(2000);//模擬耗時
                consume(queue.take());
            }catch (InterruptedException e){

            }

        }
    }

    private void consume(Integer n) {
        System.out.println("Thread:" + Thread.currentThread().getId() + " consume:" + n);

    }
}
//測試
public class Main {

    public static void main(String[] args) {
        BlockingQueue queue=new ArrayBlockingQueue(100);
        Producer p=new Producer(queue);
        Consumer c1=new Consumer(queue);
        Consumer c2=new Consumer(queue);

        new Thread(p).start();
        new Thread(c1).start();
        new Thread(c2).start();
    }
}

使用wait-notify來實現

該種方式應該最經典,這裡就不做說明瞭

如果你提交任務時，執行緒池佇列已滿，這時會發生什麼

如果你使用的LinkedBlockingQueue，也就是無界佇列的話，沒關係，繼續新增任務到阻塞佇列中等待執行，因為LinkedBlockingQueue可以近乎認為是一個無窮大的佇列，可以無限存放任務；如果你使用的是有界佇列比方說ArrayBlockingQueue的話，任務首先會被新增到ArrayBlockingQueue中，ArrayBlockingQueue滿了，則會使用拒絕策略RejectedExecutionHandler處理滿了的任務，預設是AbortPolicy。

為什麼要使用執行緒池

避免頻繁地建立和銷毀執行緒，達到執行緒物件的重用。另外，使用執行緒池還可以根據專案靈活地控制併發的數目。

java中用到的執行緒排程演演算法是什麼

搶佔式。一個執行緒用完CPU之後，作業系統會根據執行緒優先順序、執行緒饑餓情況等資料算出一個總的優先順序並分配下一個時間片給某個執行緒執行。

Thread.sleep(0)的作用是什麼

由於Java採用搶佔式的執行緒排程演演算法，因此可能會出現某條執行緒常常獲取到CPU控制權的情況，為了讓某些優先順序比較低的執行緒也能獲取到CPU控制權，可以使用Thread.sleep(0)手動觸發一次作業系統分配時間片的操作，這也是平衡CPU控制權的一種操作。

什麼是CAS

CAS，全稱為Compare and Swap，即比較-替換。假設有三個運算元：記憶體值V、舊的預期值A、要修改的值B，當且僅當預期值A和記憶體值V相同時，才會將記憶體值修改為B並傳回true，否則什麼都不做並傳回false。當然CAS一定要volatile變數配合，這樣才能保證每次拿到的變數是主記憶體中最新的那個值，否則舊的預期值A對某條執行緒來說，永遠是一個不會變的值A，只要某次CAS操作失敗，永遠都不可能成功

什麼是樂觀鎖和悲觀鎖

樂觀鎖：樂觀鎖認為競爭不總是會發生，因此它不需要持有鎖，將比較-替換這兩個動作作為一個原子操作嘗試去修改記憶體中的變數，如果失敗則表示發生衝突，那麼就應該有相應的重試邏輯。

悲觀鎖：悲觀鎖認為競爭總是會發生，因此每次對某資源進行操作時，都會持有一個獨佔的鎖，就像synchronized，不管三七二十一，直接上了鎖就操作資源了。

ConcurrentHashMap的併發度是什麼?

ConcurrentHashMap的併發度就是segment的大小，預設為16，這意味著最多同時可以有16條執行緒操作ConcurrentHashMap，這也是ConcurrentHashMap對Hashtable的最大優勢，任何情況下，Hashtable能同時有兩條執行緒獲取Hashtable中的資料嗎？

ConcurrentHashMap的工作原理

ConcurrentHashMap在jdk 1.6和jdk 1.8實現原理是不同的.

jdk 1.6:

ConcurrentHashMap是執行緒安全的，但是與Hashtablea相比，實現執行緒安全的方式不同。Hashtable是透過對hash表結構進行鎖定，是阻塞式的，當一個執行緒佔有這個鎖時，其他執行緒必須阻塞等待其釋放鎖。ConcurrentHashMap是採用分離鎖的方式，它並沒有對整個hash表進行鎖定，而是區域性鎖定，也就是說當一個執行緒佔有這個區域性鎖時，不影響其他執行緒對hash表其他地方的訪問。 
具體實現:ConcurrentHashMap內部有一個Segment

jdk 1.8

在jdk 8中，ConcurrentHashMap不再使用Segment分離鎖，而是採用一種樂觀鎖CAS演演算法來實現同步問題，但其底層還是“陣列+連結串列->紅黑樹”的實現。

CyclicBarrier和CountDownLatch區別

這兩個類非常類似，都在java.util.concurrent下，都可以用來表示程式碼執行到某個點上，二者的區別在於：

• CyclicBarrier的某個執行緒執行到某個點上之後，該執行緒即停止執行，直到所有的執行緒都到達了這個點，所有執行緒才重新執行；CountDownLatch則不是，某執行緒執行到某個點上之後，只是給某個數值-1而已，該執行緒繼續執行

• CyclicBarrier只能喚起一個任務，CountDownLatch可以喚起多個任務

• CyclicBarrier可重用，CountDownLatch不可重用，計數值為0該CountDownLatch就不可再用了

java中的++運運算元執行緒安全麼?

不是執行緒安全的操作。它涉及到多個指令，如讀取變數值，增加，然後儲存回記憶體，這個過程可能會出現多個執行緒交差

你有哪些多執行緒開發良好的實踐?

1. 給執行緒命名

2. 最小化同步範圍

3. 優先使用volatile

4. 盡可能使用更高層次的併發工具而非wait和notify()來實現執行緒通訊,如BlockingQueue,Semeaphore

5. 優先使用併發容器而非同步容器.

6. 考慮使用執行緒池

關於volatile關鍵字

可以建立Volatile陣列嗎?

Java 中可以建立 volatile型別陣列，不過只是一個指向陣列的取用，而不是整個陣列。如果改變取用指向的陣列，將會受到volatile 的保護，但是如果多個執行緒同時改變陣列的元素，volatile標示符就不能起到之前的保護作用了

volatile能使得一個非原子操作變成原子操作嗎?

一個典型的例子是在類中有一個 long 型別的成員變數。如果你知道該成員變數會被多個執行緒訪問，如計數器、價格等，你最好是將其設定為 volatile。為什麼？因為 Java 中讀取 long 型別變數不是原子的，需要分成兩步，如果一個執行緒正在修改該 long 變數的值，另一個執行緒可能只能看到該值的一半（前 32 位）。但是對一個 volatile 型的 long 或 double 變數的讀寫是原子。

一種實踐是用 volatile 修飾 long 和 double 變數，使其能按原子型別來讀寫。double 和 long 都是64位寬，因此對這兩種型別的讀是分為兩部分的，第一次讀取第一個 32 位，然後再讀剩下的 32 位，這個過程不是原子的，但 Java 中 volatile 型的 long 或 double 變數的讀寫是原子的。volatile 修複符的另一個作用是提供記憶體屏障（memory barrier），例如在分散式框架中的應用。簡單的說，就是當你寫一個 volatile 變數之前，Java 記憶體模型會插入一個寫屏障（write barrier），讀一個 volatile 變數之前，會插入一個讀屏障（read barrier）。意思就是說，在你寫一個 volatile 域時，能保證任何執行緒都能看到你寫的值，同時，在寫之前，也能保證任何數值的更新對所有執行緒是可見的，因為記憶體屏障會將其他所有寫的值更新到快取。

volatile型別變數提供什麼保證?

volatile 主要有兩方面的作用:1.避免指令重排2.可見性保證.例如，JVM 或者 JIT為了獲得更好的效能會對陳述句重排序，但是 volatile 型別變數即使在沒有同步塊的情況下賦值也不會與其他陳述句重排序。 volatile 提供 happens-before 的保證，確保一個執行緒的修改能對其他執行緒是可見的。某些情況下，volatile 還能提供原子性，如讀 64 位資料型別，像 long 和 double 都不是原子的(低32位和高32位)，但 volatile 型別的 double 和 long 就是原子的.

關於集合

Java中的集合及其繼承關係

關於集合的體系是每個人都應該爛熟於心的,尤其是對我們經常使用的List,Map的原理更該如此.這裡我們看這張圖即可: 

更多內容可見集合類總結：

http://write.blog.csdn.net/postedit/40826423

poll()方法和remove()方法區別?

poll() 和 remove() 都是從佇列中取出一個元素，但是 poll() 在獲取元素失敗的時候會傳回空，但是 remove() 失敗的時候會丟擲異常。

LinkedHashMap和PriorityQueue的區別

PriorityQueue 是一個優先順序佇列,保證最高或者最低優先順序的的元素總是在佇列頭部，但是 LinkedHashMap 維持的順序是元素插入的順序。當遍歷一個 PriorityQueue 時，沒有任何順序保證，但是 LinkedHashMap 課保證遍歷順序是元素插入的順序。

WeakHashMap與HashMap的區別是什麼?

WeakHashMap 的工作與正常的 HashMap 類似，但是使用弱取用作為 key，意思就是當 key 物件沒有任何取用時，key/value 將會被回收。

ArrayList和LinkedList的區別?

最明顯的區別是 ArrrayList底層的資料結構是陣列，支援隨機訪問，而 LinkedList 的底層資料結構是雙向迴圈連結串列，不支援隨機訪問。使用下標訪問一個元素，ArrayList 的時間複雜度是 O(1)，而 LinkedList 是 O(n)。

ArrayList和Array有什麼區別?

1. Array可以容納基本型別和物件，而ArrayList只能容納物件。

2. Array是指定大小的，而ArrayList大小是固定的

ArrayList和HashMap預設大小?

在 Java 7 中，ArrayList 的預設大小是 10 個元素，HashMap 的預設大小是16個元素（必須是2的冪）。這就是 Java 7 中 ArrayList 和 HashMap 類的程式碼片段

private static final int DEFAULT_CAPACITY = 10;

 //from HashMap.java JDK 7
 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

Comparator和Comparable的區別?

Comparable 介面用於定義物件的自然順序，而 comparator 通常用於定義使用者定製的順序。Comparable 總是隻有一個，但是可以有多個 comparator 來定義物件的順序。

如何實現集合排序?

你可以使用有序集合，如 TreeSet 或 TreeMap，你也可以使用有順序的的集合，如 list，然後透過 Collections.sort() 來排序。

如何列印陣列內容

你可以使用 Arrays.toString() 和 Arrays.deepToString() 方法來列印陣列。由於陣列沒有實現 toString() 方法，所以如果將陣列傳遞給 System.out.println() 方法，將無法打印出陣列的內容，但是 Arrays.toString() 可以列印每個元素。

LinkedList的是單向連結串列還是雙向?

雙向迴圈串列,具體實現自行查閱原始碼.

TreeMap是實現原理

採用紅黑樹實現,具體實現自行查閱原始碼.

遍歷ArrayList時如何正確移除一個元素

該問題的關鍵在於面試者使用的是 ArrayList 的 remove() 還是 Iterator 的 remove()方法。這有一段示例程式碼，是使用正確的方式來實現在遍歷的過程中移除元素，而不會出現 ConcurrentModificationException 異常的示例程式碼。

什麼是ArrayMap?它和HashMap有什麼區別?

ArrayMap是Android SDK中提供的,非Android開發者可以略過. 
ArrayMap是用兩個陣列來模擬map,更少的記憶體佔用空間,更高的效率. 
具體參考這篇文章:ArrayMap VS HashMap：http://lvable.com/?p=217%5D

HashMap的實現原理

1 HashMap概述： HashMap是基於雜湊表的Map介面的非同步實現。此實現提供所有可選的對映操作，並允許使用null值和null鍵。此類不保證對映的順序，特別是它不保證該順序恆久不變。 
2 HashMap的資料結構： 在java程式語言中，最基本的結構就是兩種，一個是陣列，另外一個是模擬指標（取用），所有的資料結構都可以用這兩個基本結構來構造的，HashMap也不例外。HashMap實際上是一個“連結串列雜湊”的資料結構，即陣列和連結串列的結合體。

當我們往Hashmap中put元素時,首先根據key的hashcode重新計算hash值,根絕hash值得到這個元素在陣列中的位置(下標),如果該陣列在該位置上已經存放了其他元素,那麼在這個位置上的元素將以連結串列的形式存放,新加入的放在鏈頭,最先加入的放入鏈尾.如果陣列中該位置沒有元素,就直接將該元素放到陣列的該位置上.

需要註意Jdk 1.8中對HashMap的實現做了最佳化,當連結串列中的節點資料超過八個之後,該連結串列會轉為紅黑樹來提高查詢效率,從原來的O(n)到O(logn)

你瞭解Fail-Fast機制嗎

Fail-Fast即我們常說的快速失敗,

更多內容參看fail-fast機制：http://blog.csdn.net/chenssy/article/details/38151189

Fail-fast和Fail-safe有什麼區別

Iterator的fail-fast屬性與當前的集合共同起作用，因此它不會受到集合中任何改動的影響。Java.util包中的所有集合類都被設計為fail->fast的，而java.util.concurrent中的集合類都為fail-safe的。當檢測到正在遍歷的集合的結構被改變時，Fail-fast迭代器丟擲ConcurrentModificationException，而fail-safe迭代器從不丟擲ConcurrentModificationException。

關於日期

SimpleDateFormat是執行緒安全的嗎?

非常不幸，DateFormat 的所有實現，包括 SimpleDateFormat 都不是執行緒安全的，因此你不應該在多執行緒序中使用，除非是在對外執行緒安全的環境中使用，如 將 SimpleDateFormat 限制在 ThreadLocal 中。如果你不這麼做，在解析或者格式化日期的時候，可能會獲取到一個不正確的結果。因此，從日期、時間處理的所有實踐來說，我強力推薦 joda-time 庫。

如何格式化日期?

Java 中，可以使用 SimpleDateFormat 類或者 joda-time 庫來格式日期。DateFormat 類允許你使用多種流行的格式來格式化日期。參見答案中的示例程式碼，程式碼中演示了將日期格式化成不同的格式，如 dd-MM-yyyy 或 ddMMyyyy。

關於異常

簡單描述java異常體系

相比沒有人不瞭解異常體系,關於異常體系的更多資訊可以見

白話異常機制：http://blog.csdn.net/dd864140130/article/details/42504189

什麼是異常鏈

詳情直接參見上面的白話異常機制,不做解釋了.

throw和throws的區別

throw用於主動丟擲java.lang.Throwable 類的一個實體化物件，意思是說你可以透過關鍵字 throw 丟擲一個 Error 或者 一個Exception，如：throw new IllegalArgumentException(“size must be multiple of 2″), 
而throws 的作用是作為方法宣告和簽名的一部分，方法被丟擲相應的異常以便呼叫者能處理。Java 中，任何未處理的受檢查異常強制在 throws 子句中宣告。

關於序列化

Java 中，Serializable 與 Externalizable 的區別

Serializable 介面是一個序列化 Java 類的介面，以便於它們可以在網路上傳輸或者可以將它們的狀態儲存在磁碟上，是 JVM 內嵌的預設序列化方式，成本高、脆弱而且不安全。Externalizable 允許你控制整個序列化過程，指定特定的二進位制格式，增加安全機制。

關於JVM

JVM特性

平臺無關性. 
Java語言的一個非常重要的特點就是與平臺的無關性。而使用Java虛擬機器是實現這一特點的關鍵。一般的高階語言如果要在不同的平臺上執行，至少需要編譯成不同的標的程式碼。而引入Java語言虛擬機器後，Java語言在不同平臺上執行時不需要重新編譯。Java語言使用樣式Java虛擬機器遮蔽了與具體平臺相關的資訊，使得Java語言編譯程式只需生成在Java虛擬機器上執行的標的程式碼（位元組碼），就可以在多種平臺上不加修改地執行。Java虛擬機器在執行位元組碼時，把位元組碼解釋成具體平臺上的機器指令執行。

簡單解釋一下類載入器

有關類載入器一般會問你四種類載入器的應用場景以及雙親委派模型,

更多的內容參看深入理解JVM載入器：

http://blog.csdn.net/dd864140130/article/details/49817357

簡述堆和棧的區別

VM 中堆和棧屬於不同的記憶體區域，使用目的也不同。棧常用於儲存方法幀和區域性變數，而物件總是在堆上分配。棧通常都比堆小，也不會在多個執行緒之間共享，而堆被整個 JVM 的所有執行緒共享。

簡述JVM記憶體分配

1. 基本資料型別比變數和物件的取用都是在棧分配的

2. 堆記憶體用來存放由new建立的物件和陣列

3. 類變數（static修飾的變數），程式在一載入的時候就在堆中為類變數分配記憶體，堆中的記憶體地址存放在棧中

4. 實體變數：當你使用java關鍵字new的時候，系統在堆中開闢並不一定是連續的空間分配給變數，是根據零散的堆記憶體地址，透過雜湊演演算法換算為一長串數字以表徵這個變數在堆中的”物理位置”,實體變數的生命週期–當實體變數的取用丟失後，將被GC（垃圾回收器）列入可回收“名單”中，但並不是馬上就釋放堆中記憶體

5. 區域性變數: 由宣告在某方法，或某程式碼段裡（比如for迴圈），執行到它的時候在棧中開闢記憶體，當區域性變數一但脫離作用域，記憶體立即釋放

其他

java當中採用的是大端還是小端?

XML解析的幾種方式和特點

DOM,SAX,PULL三種解析方式:

• DOM:消耗記憶體：先把xml檔案都讀到記憶體中，然後再用DOM API來訪問樹形結構，並獲取資料。這個寫起來很簡單，但是很消耗記憶體。要是資料過大，手機不夠牛逼，可能手機直接宕機

• SAX:解析效率高，佔用記憶體少，基於事件驅動的：更加簡單地說就是對檔案進行順序掃描，當掃描到檔案(document)開始與結束、元素(element)開始與結束、檔案(document)結束等地方時通知事件處理函式，由事件處理函式做相應動作，然後繼續同樣的掃描，直至檔案結束。

• PULL:與 SAX 類似，也是基於事件驅動，我們可以呼叫它的next（）方法，來獲取下一個解析事件（就是開始檔案，結束檔案，開始標簽，結束標簽），當處於某個元素時可以呼叫XmlPullParser的getAttributte()方法來獲取屬性的值，也可呼叫它的nextText()獲取本節點的值。

JDK 1.7特性

然 JDK 1.7 不像 JDK 5 和 8 一樣的大版本，但是，還是有很多新的特性，如 try-with-resource 陳述句，這樣你在使用流或者資源的時候，就不需要手動關閉，Java 會自動關閉。Fork-Join 池某種程度上實現 Java 版的 Map-reduce。允許 Switch 中有 String 變數和文字。菱形運運算元(<>)用於型別推斷，不再需要在變數宣告的右邊申明泛型，因此可以寫出可讀寫更強、更簡潔的程式碼

JDK 1.8特性

java 8 在 Java 歷史上是一個開創新的版本，下麵 JDK 8 中 5 個主要的特性： 
Lambda 運算式，允許像物件一樣傳遞匿名函式 
Stream API，充分利用現代多核 CPU，可以寫出很簡潔的程式碼 
Date 與 Time API，最終，有一個穩定、簡單的日期和時間庫可供你使用 
擴充套件方法，現在，介面中可以有靜態、預設方法。 
重覆註解，現在你可以將相同的註解在同一型別上使用多次。

Maven和ANT有什麼區別?

雖然兩者都是構建工具，都用於建立 Java 應用，但是 Maven 做的事情更多，在基於“約定優於配置”的概念下，提供標準的Java 專案結構，同時能為應用自動管理依賴（應用中所依賴的 JAR 檔案.

JDBC最佳實踐

• 優先使用批次操作來插入和更新資料

• 使用PreparedStatement來避免SQL漏洞

• 使用資料連線池

• 透過列名來獲取結果集

IO操作最佳實踐

• 使用有緩衝的IO類,不要單獨讀取位元組或字元

• 使用NIO和NIO 2或者AIO,而非BIO

• 在finally中關閉流

• 使用記憶體對映檔案獲取更快的IO

好的東西要和朋友一起分享，趕快將本文分享給你身邊正在準備Java面試的朋友吧！

●編號684，輸入編號直達本文

●輸入m獲取文章目錄