寫在前面：準備面試已經一段時間了，這期間看了不少知識點，刷了不少題目，但是沒怎麼記錄。今天上byr時無意間看到學姐整理的一份面試記錄，感覺很不錯。所以讓我也產生了記錄面試的念頭，首先就從面試前的一些基礎知識上開始吧，這些都是最基本的概念，還是有必要做一個全面的總結。

JAVA

java記憶體，堆疊特點與存放物件，值傳遞址傳遞（此處有坑），虛擬機器GC演算法原理

棧： 存放基本型別的變數資料和物件的引用，但物件本身不存放在棧中，而是存放在堆（new出來的物件）或者常量池中（字串常量物件存放在常量池中。）==存取速度比堆要快，僅次於暫存器==

堆：存放所有new出來的物件，==堆的優勢是可以動態地分配記憶體大小==，生存期也不必事先告訴編譯器

靜態域： 存放靜態成員（static定義的）

常量池： 存放字串常量和基本型別常量（public static final）

這裡我們主要關心棧，堆和常量池，對於棧和常量池中的物件可以共享，對於堆中的物件不可以共享。==棧中的資料大小和生命週期必須是確定的，當沒有引用指向資料時，這個資料就會消失。堆中的物件由垃圾回收器負責回收，因此大小和生命週期不需要確定，具有很大的靈活性。==

在函式中定義的一些基本型別的變數資料和物件的引用變數都在函式的棧記憶體中分配。 當在一段程式碼塊定義一個變數時，Java在棧中為這個變數分配記憶體空間，當該變數退出其作用域後，Java會自動釋放掉為該變數所分配的記憶體空間

，該記憶體空間可以立即被另作他用。

引用變數是普通的變數，定義時在棧中分配，引用變數在程式執行到其作用域之外後被釋放。而陣列和物件本身在堆中分配，即使程式執行到使用new產生陣列或者物件的語句所在的程式碼塊之外，陣列和物件本身佔據的記憶體不會被釋放，陣列和物件在沒有引用變數指向它的時候，才變為垃圾，不能在被使用，但仍然佔據記憶體空間不放，在隨後的一個不確定的時間被垃圾回收器收走（釋放掉）。==這也是 Java 比較佔記憶體的原因==。

引數是按值而不是按引用傳遞的說明==Java應用程式有且僅有的一種引數傳遞機制，即按值傳遞。== 值傳遞的精髓是：傳遞的是儲存單元中的內容，而非地址或者引用！

在Java應用程式中永遠不會傳遞物件，而只傳遞物件引用。因此是按引用傳遞物件。Java應用程式按引用傳遞物件這一事實並不意味著Java應用程式按引用傳遞引數。引數可以是物件引用，而Java應用程式是按值傳遞物件引用的。

按值傳遞和按引用傳遞。按值傳遞意味著當將一個引數傳遞給一個函式時，函式接收的是原始值的一個副本。因此，如果函式修改了該引數，僅改變副本，而原始值保持不變。按引用傳遞意味著當將一個引數傳遞給一個函式時，函式接收的是原始值的記憶體地址，而不是值的副本。因此，如果函式修改了該引數，呼叫程式碼中的原始值也隨之改變。

//定義了一個改變引數值的函式  
public static void changeValue(int x) {  
x = x *2;  
}  
//呼叫該函式  
int num = 5;  
System.out.println(num);  
changeValue(num);  
System.out.println(num);  

答案顯而易見，呼叫函式changeValue()前後num的值都沒有改變。

由此做一個引子，我用圖表描繪一個值傳遞的過程：

num作為引數傳遞給changeValue()方法時，是將記憶體空間中num所指向的那個儲存單元中存放的值，即”5”,傳送給了changeValue()方法中的x變數，而這個x變數也在記憶體空間中分配了一個儲存單元，這個時候，就把num的值5傳送給了這個儲存單元中。此後，在changeValue()方法中對x的一切操作都是針對x所指向的這個儲存單元，與num所指向的那個儲存單元沒有關係了！自然，在函式呼叫之後，num所指向的儲存單元的值還是沒有發生變化，這就是所謂的“值傳遞”！值傳遞的精髓是：==傳遞的是儲存單元中的內容，而非地址或者引用！==

接下來，就來看java中的物件引數是怎麼傳遞的：

同樣，先給出一段程式碼：

... ...  
class person {  
public static String name = "Jack";  
... ...  
}  
... ...  
//定義一個改變物件屬性的方法  
public static void changeName(Person p) {  
p.name = "Rose";  
}  
... ...  
public static void main(String[] args) {  
//定義一個Person物件，person是這個物件的引用  
Person person = new Person();  
//先顯示這個物件的name屬性  
System.out.println(person.name);  
//呼叫changeName(Person p)方法  
changeName(person);  
//再顯示這個物件的name屬性，看是否發生了變化  
System.out.println(person.name);  
}  

第一次顯示：“Jack”

第二次顯示：“Rose”

這裡就有一個問題了，++當一個物件被當作引數傳遞到一個方法後，此方法可改變這個物件的屬性，並可返回變化後的結果，那麼這裡到底是值傳遞還是引用傳遞?++

答:是值傳遞。Java程式語言只有值傳遞引數。==當一個物件例項作為一個引數被傳遞到方法中時，引數的值就是該物件的引用一個副本。指向同一個物件,物件的內容可以在被呼叫的方法中改變，但物件的引用(不是引用的副本)是永遠不會改變的。==

為什麼這裡是“值傳遞”，而不是“引用傳遞”？

我還是用圖表描繪比較能解釋清楚：

主函式中new 了一個物件Person，實際分配了兩個物件：新建立的Person類的實體物件，和指向該物件的引用變數person。

【注意：在java中，新建立的實體物件在堆記憶體中開闢空間，而引用變數在棧記憶體中開闢空間】

正如如上圖所示，左側是堆空間，用來分配記憶體給新建立的實體物件，紅色框是新建的Person類的實體物件，000012是該實體物件的起始地址；而右側是棧空間，用來給引用變數和一些臨時變數分配記憶體，新實體物件的引用person就在其中，可以看到它的儲存單元的內容是000012，記錄的正是新建Person類實體物件的起始地址，也就是說它指向該實體物件。

這時候，好戲上臺了：

呼叫了changeName()方法，person作為物件引數傳入該方法，但是大家特別注意，它傳入的是什麼！！！person引用變數將自己的儲存單元的內容傳給了changeName()方法的p變數！也就是將實體物件的地址傳給了p變數，從此，在changeName()方法中對p的一切操作都是針對p所指向的這個儲存單元，與person引用變數所指向的那個儲存單元再沒有關係了！

回顧一下上面的一個值傳遞的例子，值傳遞，就是將儲存單元中的內容傳給呼叫函式中的那個引數，這裡是不是異曲同工，是所謂“值傳遞”，而非“引用傳遞”！！！

那為什麼物件內部能夠發生變化呢？

那是因為：p所指向的那個儲存單元中的內容是實體物件的地址，使得p也指向了該實體物件，所以才能改變物件內部的屬性！
這也是我們大多數人會誤以為是“引用傳遞”的終極原因！！！

Java建立物件的過程

Java是一門面向物件的程式語言，在Java程式執行過程中每時每刻都有物件被創建出來。在語言層面上,建立物件通常僅僅是一個new關鍵字而已，而在虛擬機器中，物件的建立又是怎樣一個過程呢？

一、檢測類是否被載入

虛擬機器遇到一條new指令時，首先將去檢查這個指令的引數是否能在常量池中定位到一個類的符號引用，並且檢查這個符號引用代表的類是否已被載入、解析和初始化過。如果沒有，那必須先執行相應的類載入過程。

二、為新生物件分配記憶體

在類載入檢查通過後，接下來虛擬機器將為新生物件分配記憶體。物件所需記憶體的大小在類載入完成後便可完全確定。

三、初始化零值

記憶體分配完成後，虛擬機器需要將分配到的記憶體空間都初始化為零值（不包括物件頭），這一步操作保證了物件的例項欄位在Java程式碼中可以不賦初始值就直接使用，程式能訪問到這些欄位的資料型別所對應的零值。

四、進行必要的設定

接下來，虛擬機器要對物件進行必要的設定，例如這個物件是哪個類的例項、如何才能找到類的元資料資訊、物件的雜湊碼、物件的GC分代年齡等資訊。這些資訊存放在物件的物件頭之中。

五、執行init方法

在上面工作都完成之後，從虛擬機器的視角來看，一個新的物件已經產生了，但從Java程式的視角來看，物件建立才剛開始，方法還沒有執行，所有的欄位都還為零。所以一般來說，執行new指令之後會接著執行方法，把物件按照程式設計師的意願進行初始化，這樣一個真正可用的物件才算完全產生出來。

總結一下上面所說的，建立一個物件的過程就是：

檢測類是否被載入沒有載入的先載入→為新生物件分配記憶體→將分配到的記憶體空間都初始化為零值→對物件進行必要的設定→執行方法把物件進行初始化

Set，Map，List等的原理特性，尤其是ArrayList，HashMap，HashTable，ConcurrentHashMap等，是否執行緒安全？如何解決hash衝突？等等

這裡記一下執行緒安全和非執行緒安全：

ArrayList是非執行緒安全的，Vector是執行緒安全的；HashMap是非執行緒安全的，HashTable是執行緒安全的；StringBuilder是非執行緒安全的，StringBuffer是執行緒安全的。

如果你的程式碼所在的程序中有多個執行緒在同時執行，而這些執行緒可能會同時執行這段程式碼。如果每次執行結果和單執行緒執行的結果是一樣的，而且其他的變數的值也和預期的是一樣的，就是執行緒安全的。

非執行緒安全是指多執行緒操作同一個物件可能會出現問題。而執行緒安全則是多執行緒操作同一個物件不會有問題。

執行緒安全必須要使用很多synchronized關鍵字來同步控制，所以必然會導致效能的降低。

比如一個 ArrayList 類，在新增一個元素的時候，它可能會有兩步來完成：1. 在 Items[Size] 的位置存放此元素；2.增大Size的值。在單執行緒執行的情況下，如果 Size = 0，新增一個元素後，此元素在位置 0，而且 Size=1；

而如果是在多執行緒情況下，比如有兩個執行緒，執行緒A先將元素存放在位置 0。但是此時CPU排程執行緒A暫停，執行緒B得到執行的機會。執行緒B也向此 ArrayList 新增元素，因為此時 Size 仍然等於 0 （注意哦，我們假設的是新增一個元素是要兩個步驟哦，而執行緒A僅僅完成了步驟1），所以執行緒B也將元素存放在位置0。然後執行緒A和執行緒B都繼續執行，都增加Size的值。那好，現在我們來看看ArrayList的情況，元素實際上只有一個，存放在位置 0，而 Size 卻等於 2。這就是“執行緒不安全”了。

非執行緒安全!=不安全

有人在使用過程中有一個不正確的觀點：我的程式是多執行緒的，不能使用ArrayList要使用Vector，這樣才安全。

非執行緒安全並不是多執行緒環境下就不能使用。注意我上面有說到：多執行緒操作同一個物件。注意是同一個物件。比如最上面那個模擬，就是在主執行緒中new的一個ArrayList然後多個執行緒操作同一個ArrayList物件。如果是每個執行緒中new一個ArrayList，而這個ArrayList只在這一個執行緒中使用，那麼肯定是沒問題的。

ArrayList、LinkedList、Vector的區別

1. ArrayList是實現了基於動態陣列的資料結構，LinkedList基於連結串列的資料結構。

2. 對於隨機訪問get和set，ArrayList覺得優於LinkedList，因為LinkedList要移動指標。

3. 對於新增和刪除操作add和remove，LinedList比較佔優勢，因為ArrayList要移動資料。
4. Vector 和ArrayList類似,但屬於強同步類。如果你的程式本身是執行緒安全的(thread-safe,沒有在多個執行緒之間共享同一個集合/物件),那麼使用ArrayList是更好的選擇。
5. 資料增長:當需要增長時,Vector預設增長為原來一培，而ArrayList卻是原來的一半
6. LinkedList 還實現了 Queue 介面,該介面比List提供了更多的方法,包括 offer(),peek(),poll()等.

String、StringBuffer與StringBuilder的區別
1. String用於存放字元的陣列被宣告為final的，因此只能賦值一次，不可再更改。
2. 要是需要多次更改，需要用到StringBulider或者StringBuffer，兩者不同點在於StringBuffer是執行緒安全的。
3. StringBulider轉為String：
String m = sb.toString();
String轉StringBuilder：
StringBuilder sb = new StringBuilder(m);

HashMap和HashTable的區別。

1. 歷史原因:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map介面的一個實現
2. 同步性:Hashtable是執行緒安全的，也就是說是同步的，而HashMap是執行緒序不安全的，不是同步的
3. 只有HashMap可以讓你將空值作為一個表的條目的key或value

怎麼解決Hash衝突？

1. 開放定址法

用開放定址法解決衝突的做法是：當衝突發生時，使用某種探查(亦稱探測)技術在散列表中形成一個探查(測)序列。沿此序列逐個單元地查詢，直到找到給定的關鍵字，或者碰到一個開放的地址(即該地址單元為空)為止（若要插入，在探查到開放的地址，則可將待插入的新結點存人該地址單元）。查詢時探查到開放的 地址則表明表中無待查的關鍵字，即查詢失敗。

按照形成探查序列的方法不同，可將開放定址法區分為線性探查法、線性補償探測法、隨機探測等。

1. 拉鍊法

拉鍊法解決衝突的做法是：將所有關鍵字為同義詞的結點連結在同一個單鏈表中。 若選定的散列表長度為m，則可將散列表定義為一個由m個頭指標組成的指標陣列T[0..m-1]。凡是雜湊地址為i的結點，均插入到以T[i]為頭指標的單鏈表中。T中各分量的初值均應為空指標。在拉鍊法中，裝填因子α可以大於 1，但一般均取α≤1。

與開放定址法相比，拉鍊法有如下幾個優點：

①拉鍊法處理衝突簡單，且無堆積現象，即非同義詞決不會發生衝突，因此平均查詢長度較短；

②由於拉鍊法中各連結串列上的結點空間是動態申請的，故它更適合於造表前無法確定表長的情況；

③開放定址法為減少衝突，要求裝填因子α較小，故當結點規模較大時會浪費很多空間。而拉鍊法中可取α≥1，且結點較大時，拉鍊法中增加的指標域可忽略不計，因此節省空間；

④在用拉鍊法構造的散列表中，刪除結點的操作易於實現。只要簡單地刪去連結串列上相應的結點即可。而對開放地址法構造的散列表，刪除結點不能簡單地將被刪結點的空間置為空，否則將截斷在它之後填人散列表的同義詞結點的查詢路徑。這是因為各種開放地址法中，空地址單元(即開放地址)都是查詢失敗的條件。因此在用開放地址法處理衝突的散列表上執行刪除操作，只能在被刪結點上做刪除標記，而不能真正刪除結點。

拉鍊法的缺點是：==指標需要額外的空間==，故當結點規模較小時，開放定址法較為節省空間

設計模式，尤其是單例模式的餓漢子飽漢子各種寫法，被考過n多次

JAVA總共有23種設計模式，而常見的設計模式有6種（其實是自己只熟悉這6種）：

1. 單例模式

Java中單例模式是一種常見的設計模式，單例模式的寫法有好幾種，這裡主要介紹兩種 ==：懶漢式單例、餓漢式單例。==

單例模式有以下特點：

• 單例模式只能有一個例項。
• 單例類必須自己建立自己的唯一例項。
• 單例類必須給所有其他物件提供這一例項。

單例模式確保某個類只有一個例項，而且自行例項化並向整個系統提供這個例項。在計算機系統中，執行緒池、快取、日誌物件、對話方塊、印表機、顯示卡的驅動程式物件常被設計成單例。這些應用都或多或少具有資源管理器的功能。每臺計算機可以有若干個印表機，但只能有一個Printer Spooler， 以避免兩個列印作業同時輸出到印表機中。每臺計算機可以有若干通訊埠，系統應當集中管理這些通訊埠，以避免一個通訊埠同時被兩個請求同時呼叫。總之，選擇單例模式就是為了避免不一致狀態，避免政出多頭。

懶漢式單例

//懶漢式單例類.在第一次呼叫的時候例項化自己   
public class Singleton{
    private static Singleton instance=null;
    public static　synchronized　Singleton getInstance(){
        if(instance==null){
               instance=new Singleton();
        }
        return instance;
    }
    private Singleton(){
    }
}

Singleton通過將構造方法限定為private避免了類在外部被例項化，在同一個虛擬機器範圍內，Singleton的唯一例項只能通過getInstance()方法訪問。

餓漢式單例

//餓漢式單例類.在類初始化時，已經自行例項化   
public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    public static Singleton1 getInstance() {  
        return single;  
    }  
}  

餓漢式在類建立的同時就已經建立好一個靜態的物件供系統使用，以後不再改變，所以天生是執行緒安全的。

餓漢式和懶漢式區別

從名字上來說，餓漢和懶漢，

餓漢就是類一旦載入，就把單例初始化完成，保證getInstance的時候，單例是已經存在的了，

而懶漢比較懶，只有當呼叫getInstance的時候，才回去初始化這個單例。

另外從以下兩點再區分以下這兩種方式：

1、執行緒安全：

餓漢式天生就是執行緒安全的，可以直接用於多執行緒而不會出現問題，

懶漢式本身是非執行緒安全的，為了實現執行緒安全就在getInstance上加同步鎖。

2、資源載入和效能：

餓漢式在類建立的同時就例項化一個靜態物件出來，不管之後會不會使用這個單例，都會佔據一定的記憶體，但是相應的，在第一次呼叫時速度也會更快，因為其資源已經初始化完成，

而懶漢式顧名思義，會延遲載入，在第一次使用該單例的時候才會例項化物件出來，第一次呼叫時要做初始化，如果要做的工作比較多，效能上會有些延遲，之後就和餓漢式一樣了。

2. 工廠模式

模式的問題：你如何能輕鬆方便地構造物件例項，而不必關心構造物件例項的細節和複雜過程呢？

解決方案： 建立一個工廠來建立物件

工廠模式的兩種情況：

1.在編碼時不能預見需要建立哪種類的例項。

2.系統不應依賴於產品類例項如何被建立、組合和表達的細節

工廠模式定義

我們以類Sample為例， 如果我們要建立Sample的例項物件:
Sample sample=new Sample();

可是，實際情況是，通常我們都要在建立sample例項時做點初始化的工作,比如賦值 查詢資料庫等。

首先，我們想到的是，可以使用Sample的建構函式，這樣生成例項就寫成:
Sample sample=new Sample(引數);

但是，如果建立sample例項時所做的初始化工作不是像賦值這樣簡單的事，可能是很長一段程式碼，如果也寫入建構函式中，那你的程式碼很難看了（就需要Refactor重整）。

為什麼說程式碼很難看，初學者可能沒有這種感覺，我們分析如下，初始化工作如果是很長一段程式碼，說明要做的工作很多，將很多工作裝入一個方法中，相當於將很多雞蛋放在一個籃子裡，是很危險的，這也是有悖於Java面向物件的原則。

面向物件的封裝(Encapsulation)和分派(Delegation)告訴我們，儘量將長的程式碼分派“切割”成每段，將每段再“封裝”起來(減少段和段之間耦合聯絡性)，這樣，就會將風險分散，以後如果需要修改，只要更改每段，不會再發生牽一動百的事情。

在本例中，首先，我們需要將建立例項的工作與使用例項的工作分開, 也就是說，讓建立例項所需要的大量初始化工作從Sample的建構函式中分離出去。

這時我們就需要Factory工廠模式來生成物件了，不能再用上面簡單new Sample(引數)。還有,如果Sample有個繼承如MySample, 按照面向介面程式設計,我們需要將Sample抽象成一個介面.ISample是介面,有兩個子類MySample 和HisSample .我們要例項化他們時,如下:

ISample mysample=new MySample();

ISample hissample=new HisSample();

隨著專案的深入,Sample可能還會”生出很多兒子出來”, 那麼我們要對這些兒子一個個例項化,更糟糕的是,可能還要對以前的程式碼進行修改:加入後來生出兒子的例項.這在傳統程式中是無法避免的.
但如果你一開始就有意識使用了工廠模式,這些麻煩就沒有了.

3. 建造者模式

該模式其實就是說，一個物件的組成可能有很多其他的物件一起組成的，比如說，一個物件的實現非常複雜，有很多的屬性，而這些屬性又是其他物件的引用，可能這些物件的引用又包括很多的物件引用。封裝這些複雜性，就可以使用建造模式。

定義

將一個複雜物件的構造與它的表示分離，使同樣的構建過程可以建立不同的表示，這樣的設計模式被稱為建造者模式。

實用範圍

相同的方法，不同的執行順序，產生不同的事件結果時，可以採用建造者模式。

多個部件或零件,都可以裝配到一個物件中，但是產生的執行結果又不相同時，則可以使用該模式。

產品類非常複雜，或者產品類中的呼叫順序不同產生了不同的效能，這個時候使用建造者模式是非常合適。

在物件建立過程中會使用到系統中的一些其它物件，這些物件在產品物件的建立過程中不易得到時，也可以採用建造者模式封裝該物件的建立過程。該種場景，只能是一個補償方法，因為一個物件不容易獲得，而在設計階段竟然沒有發覺，而要通過建立者模式柔化建立過程，本身已經違反設計最初目標。

4. 門面模式

外部與一個子系統的通訊必須通過一個統一的門面(Facade)物件進行，這就是門面模式。門面模式提供一個高層次的介面，使得子系統更易於使用。

就如同醫院的接待員一樣，門面模式的門面類將客戶端與子系統的內部複雜性分隔開，使得客戶端只需要與門面物件打交道，而不需要與子系統內部的很多物件打交道。

適用範圍：

為一個複雜子系統提供一個簡單介面

提高子系統的獨立性

在層次化結構中，可以使用Facade模式定義系統中每一層的入口。

5. 策略模式

定義一系列的演算法,把每一個演算法封裝起來, 並且使它們可相互替換。本模式使得演算法可獨立於使用它的客戶而變化。

把一個類中經常改變或者將來可能改變的部分提取出來，作為一個介面，然後在類中包含這個物件的例項，這樣類的例項在執行時就可以隨意呼叫實現了這個介面的類的行為。
比如定義一系列的演算法,把每一個演算法封裝起來, 並且使它們可相互替換，使得演算法可獨立於使用它的客戶而變化。這就是策略模式。

適用情況

許多相關的類僅僅是行為有異。

“策略”提供了一種用多個行為中的一個行為來配置一個類的方法。即一個系統需要動態地在幾種演算法中選擇一種。

當一個應用程式需要實現一種特定的服務或者功能，而且該程式有多種實現方式時使用。一個類定義了多種行為,並且這些行為在這個類的操作中以多個條件語句的形式出現。將相關的條件分支移入它們各自的Strategy類中以代替這些條件語句。

6. 觀察者模式

觀察者模式是軟體設計模式的一種。有時被稱作釋出/訂閱模式，觀察者模式定義了一種一對多的依賴關係，讓多個觀察者物件同時監聽某一個主題物件。這個主題物件在狀態發生變化時，會通知所有觀察者物件，使它們能夠自動更新自己。此種模式通常被用來實現事件處理系統。