獻給java求職路上的大家

爲了更好的樹立知識體系,我附加了相關的思惟導圖,分爲pdf版和mindnote版.好比java相關的導圖以下:

因爲時間倉促,有些地方未寫完,後面會繼續補充.若有不妥之處,歡迎及時與我溝通.

---

相關概念

面向對象的三個特徵

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

多態的好處

容許不一樣類對象對同一消息作出響應,即同一消息能夠根據發送對象的不一樣而採用多種不一樣的行爲方式(發送消息就是函數調用).主要有如下優勢:

1. 可替換性:多態對已存在代碼具備可替換性.
2. 可擴充性:增長新的子類不影響已經存在的類結構.
3. 接口性:多態是超類經過方法簽名,向子類提供一個公共接口,由子類來完善或者重寫它來實現的.
4. 靈活性:
5. 簡化性:

代碼中如何實現多態

實現多態主要有如下三種方式:
1. 接口實現
2. 繼承父類重寫方法
3. 同一類中進行方法重載

虛擬機是如何實現多態的

動態綁定技術(dynamic binding),執行期間判斷所引用對象的實際類型,根據實際類型調用對應的方法.

接口的意義

接口的意義用三個詞就能夠歸納:規範,擴展,回調.

抽象類的意義

抽象類的意義能夠用三句話來歸納:

1. 爲其餘子類提供一個公共的類型
2. 封裝子類中重複定義的內容
3. 定義抽象方法,子類雖然有不一樣的實現,可是定義時一致的

接口和抽象類的區別

比較	抽象類	接口
默認方法	抽象類能夠有默認的方法實現	,java 8以前,接口中不存在方法的實現.
實現方式	子類使用extends關鍵字來繼承抽象類.若是子類不是抽象類,子類須要提供抽象類中所聲明方法的實現.	子類使用implements來實現接口,須要提供接口中全部聲明的實現.
構造器	抽象類中能夠有構造器,	接口中不能
和正常類區別	抽象類不能被實例化	接口則是徹底不一樣的類型
訪問修飾符	抽象方法能夠有public,protected和default等修飾	接口默認是public,不能使用其餘修飾符
多繼承	一個子類只能存在一個父類	一個子類能夠存在多個接口
添加新方法	想抽象類中添加新方法,能夠提供默認的實現,所以能夠不修改子類現有的代碼	若是往接口中添加新方法,則子類中須要實現該方法.

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

不能.重寫只適用於實例方法,不能用於靜態方法,而子類當中含有和父類相同簽名的靜態方法,咱們通常稱之爲隱藏.

什麼是不可變對象

不可變對象指對象一旦被建立，狀態就不能再改變。任何修改都會建立一個新的對象，如 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);//返回false

Object中有哪些公共方法?

1. equals()
2. clone()
3. getClass()
4. notify(),notifyAll(),wait()
5. toString

java當中的四種引用

強引用,軟引用,弱引用,虛引用.不一樣的引用類型主要體如今GC上:

1. 強引用：若是一個對象具備強引用，它就不會被垃圾回收器回收。即便當前內存空間不足，JVM也不會回收它，而是拋出 OutOfMemoryError 錯誤，使程序異常終止。若是想中斷強引用和某個對象之間的關聯，能夠顯式地將引用賦值爲null，這樣一來的話，JVM在合適的時間就會回收該對象
2. 軟引用：在使用軟引用時，若是內存的空間足夠，軟引用就能繼續被使用，而不會被垃圾回收器回收，只有在內存不足時，軟引用纔會被垃圾回收器回收。
3. 弱引用：具備弱引用的對象擁有的生命週期更短暫。由於當 JVM 進行垃圾回收，一旦發現弱引用對象，不管當前內存空間是否充足，都會將弱引用回收。不過因爲垃圾回收器是一個優先級較低的線程，因此並不必定能迅速發現弱引用對象
4. 虛引用：顧名思義，就是形同虛設，若是一個對象僅持有虛引用，那麼它至關於沒有引用，在任什麼時候候均可能被垃圾回收器回收。

更多瞭解參見深刻對象引用

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"); } } } 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

以上代碼將會拋出空指針異常.

一個.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{ //執行相關操做 } }

• 1
• 2
• 3
• 4
• 5

• 1
• 2
• 3
• 4
• 5

此外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)); } } 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

final有哪些用法

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

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

---

數據類型相關

java中int char,long各佔多少字節?

類型	位數	字節數
short	2	16
int	4	32
long	8	64
float	4	32
double	8	64
char	2	16

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. 分代回收
更詳細的內容參見深刻理解垃圾回收算法

如何判斷一個對象是否應該被回收

這就是所謂的對象存活性判斷,經常使用的方法有兩種: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 提供了大量方法來支持阻塞，下面讓咱們逐一分析。

方法	說明
sleep()	sleep() 容許 指定以毫秒爲單位的一段時間做爲參數，它使得線程在指定的時間內進入阻塞狀態，不能獲得CPU 時間，指定的時間一過，線程從新進入可執行狀態。 典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不知足後，讓線程阻塞一段時間後從新測試，直到條件知足爲止
suspend() 和 resume()	兩個方法配套使用，suspend()使得線程進入阻塞狀態，而且不會自動恢復，必須其對應的resume() 被調用，才能使得線程從新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另外一個線程產生的結果的情形：測試發現結果尚未產生後，讓線程阻塞，另外一個線程產生告終果後，調用 resume() 使其恢復。
yield()	yield() 使當前線程放棄當前已經分得的CPU 時間，但不使當前線程阻塞，即線程仍處於可執行狀態，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價於調度程序認爲該線程已執行了足夠的時間從而轉到另外一個線程
wait() 和 notify()	兩個方法配套使用，wait() 使得線程進入阻塞狀態，它有兩種形式，一種容許 指定以毫秒爲單位的一段時間做爲參數，另外一種沒有參數，前者當對應的 notify() 被調用或者超出指定時間時線程從新進入可執行狀態，後者則必須對應的 notify() 被調用.

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 }

• 1
• 2
• 3
• 4
• 5

• 1
• 2
• 3
• 4
• 5

什麼是線程局部變量ThreadLocal

線程局部變量是侷限於線程內部的變量，屬於線程自身全部，不在多個線程間共享。Java提供ThreadLocal類來支持線程局部變量，是一種實現線程安全的方式。可是在管理環境下（如 web 服務器）使用線程局部變量的時候要特別當心，在這種狀況下，工做線程的生命週期比任何應用變量的生命週期都要長。任何線程局部變量一旦在工做完成後沒有釋放，Java 應用就存在內存泄露的風險。

ThreadLoal的做用是什麼?

簡單說ThreadLocal就是一種以空間換時間的作法在每一個Thread裏面維護了一個ThreadLocal.ThreadLocalMap把數據進行隔離，數據不共享，天然就沒有線程安全方面的問題了.

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

（1）經過平衡生產者的生產能力和消費者的消費能力來提高整個系統的運行效率，這是生產者消費者模型最重要的做用
（2）解耦，這是生產者消費者模型附帶的做用，解耦意味着生產者和消費者之間的聯繫少，聯繫越少越能夠獨自發展而不須要收到相互的制約

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

能夠經過阻塞隊列實現,也能夠經過wait-notify來實現.

使用阻塞隊列來實現

//消費者 public class Producer implements Runnable{ private final BlockingQueue<Integer> 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<Integer> 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<Integer> queue=new ArrayBlockingQueue<Integer>(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(); } } 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67

使用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的原理更該如此.這裏咱們看這張圖便可:

更多內容可見集合類總結

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

• 1
• 2
• 3
• 4

• 1
• 2
• 3
• 4

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

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機制

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異常體系

相比沒有人不瞭解異常體系,關於異常體系的更多信息能夠見:白話異常機制

什麼是異常鏈

詳情直接參見白話異常機制,不作解釋了.

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加載器

簡述堆和棧的區別

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操做最佳實踐

1. 使用有緩衝的IO類,不要單獨讀取字節或字符
2. 使用NIO和NIO 2或者AIO,而非BIO
3. 在finally中關閉流
4. 使用內存映射文件獲取更快的IO