2023編程精選題庫：Java面試題集及參考答案相關概念面向對象的三個特征封裝,繼承,多態.這個應該是人人皆知.有時候也會加上抽象.多態的好處允許不同類對象對同一消息做出響應,即同一消息可以根據發送對象的不同而采用多種不同的行為方式(發送消息就是函數調用).主要有以下優點:可替換性:多態對已存在代碼具有可替換性.可擴充性:增加新的子類不影響已經存在的類結構.接口性:多態是超類通過方法簽名,向子類提供一個公共接口,由子類來完善或者重寫它來實現的.靈活性.簡化性.代碼中如何實現多態實現多態主要有以下三種方式:

1.接口實現

2.繼承父類重寫方法

3.同一類中進行方法重載虛擬機是如何實現多態的動態綁定技術(dynamicbinding),執行期間判斷所引用對象的實際類型,根據實際類型調用對應的方法.接口的意義接口的意義用三個詞就可以概括:規范,擴展,回調.抽象類的意義抽象類的意義可以用三句話來概括:為其他子類提供一個公共的類型封裝子類中重復定義的內容定義抽象方法,子類雖然有不同的實現,但是定義時一致的接口和抽象類的區別比較抽象類接口默認方法抽象類可以有默認的方法實現java8之前,接口中不存在方法的實現.實現方式子類使用extends關鍵字來繼承抽象類.如果子類不是抽象類,子類需要提供抽象類中所聲明方法的實現.子類使用implements來實現接口,需要提供接口中所有聲明的實現.構造器抽象類中可以有構造器,接口中不能和正常類區別抽象類不能被實例化接口則是完全不同的類型訪問修飾符抽象方法可以有public,protected和default等修飾接口默認是public,不能使用其他修飾符多繼承一個子類只能存在一個父類一個子類可以存在多個接口添加新方法想抽象類中添加新方法,可以提供默認的實現,因此可以不修改子類現有的代碼如果往接口中添加新方法,則子類中需要實現該方法.父類的靜態方法能否被子類重寫不能.重寫只適用于實例方法,不能用于靜態方法,而子類當中含有和父類相同簽名的靜態方法,我們一般稱之為隱藏.什么是不可變對象不可變對象指對象一旦被創建，狀態就不能再改變。任何修改都會創建一個新的對象，如String、Integer及其它包裝類。靜態變量和實例變量的區別?靜態變量存儲在方法區,屬于類所有.實例變量存儲在堆當中,其引用存在當前線程棧.能否創建一個包含可變對象的不可變對象?當然可以創建一個包含可變對象的不可變對象的，你只需要謹慎一點，不要共享可變對象的引用就可以了，如果需要變化時，就返回原對象的一個拷貝。最常見的例子就是對象中包含一個日期對象的引用.java創建對象的幾種方式采用new通過反射采用clone通過序列化機制前2者都需要顯式地調用構造方法.造成耦合性最高的恰好是第一種,因此你發現無論什么框架,只要涉及到解耦必先減少new的使用.switch中能否使用string做參數在idk1.7之前,switch只能支持byte,short,char,int或者其對應的封裝類以及Enum類型。從idk1.7之后switch開始支持String.switch能否作用在byte,long上?可以用在byte上,但是不能用在long上.Strings1=”ab”,Strings2=”a”+”b”,Strings3=”a”,Strings4=”b”,s5=s3+s4請問s5==s2返回什么?返回false.在編譯過程中,編譯器會將s2直接優化為”ab”,會將其放置在常量池當中,s5則是被創建在堆區,相當于s5=newString(“ab”);你對String對象的intern()熟悉么?intern()方法會首先從常量池中查找是否存在該常量值,如果常量池中不存在則現在常量池中創建,如果已經存在則直接返回.

比如

Strings1=”aa”;

Strings2=ern();

System.out.print(s1==s2);//返回trueObject中有哪些公共方法?equals()clone()getClass()notify(),notifyAll(),wait()toStringjava當中的四種引用強引用,軟引用,弱引用,虛引用.不同的引用類型主要體現在GC上:強引用：如果一個對象具有強引用，它就不會被垃圾回收器回收。即使當前內存空間不足，JVM也不會回收它，而是拋出OutOfMemoryError錯誤，使程序異常終止。如果想中斷強引用和某個對象之間的關聯，可以顯式地將引用賦值為null，這樣一來的話，JVM在合適的時間就會回收該對象軟引用：在使用軟引用時，如果內存的空間足夠，軟引用就能繼續被使用，而不會被垃圾回收器回收，只有在內存不足時，軟引用才會被垃圾回收器回收。弱引用：具有弱引用的對象擁有的生命周期更短暫。因為當JVM進行垃圾回收，一旦發現弱引用對象，無論當前內存空間是否充足，都會將弱引用回收。不過由于垃圾回收器是一個優先級較低的線程，所以并不一定能迅速發現弱引用對象虛引用：顧名思義，就是形同虛設，如果一個對象僅持有虛引用，那么它相當于沒有引用，在任何時候都可能被垃圾回收器回收。WeakReference與SoftReference的區別?這點在四種引用類型中已經做了解釋,這里簡單說明一下即可:

雖然WeakReference與SoftReference都有利于提高GC和內存的效率，但是WeakReference，一旦失去最后一個強引用，就會被GC回收，而軟引用雖然不能阻止被回收，但是可以延遲到JVM內存不足的時候。為什么要有不同的引用類型不像C語言,我們可以控制內存的申請和釋放,在Java中有時候我們需要適當的控制對象被回收的時機,因此就誕生了不同的引用類型,可以說不同的引用類型實則是對GC回收時機不可控的妥協.有以下幾個使用場景可以充分的說明:利用軟引用和弱引用解決OOM問題：用一個HashMap來保存圖片的路徑和相應圖片對象關聯的軟引用之間的映射關系，在內存不足時，JVM會自動回收這些緩存圖片對象所占用的空間，從而有效地避免了OOM的問題.通過軟引用實現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則不會自動進行類型轉換.如：

bytea=127;

byteb=127;

b=a+b;//error:cannotconvertfrominttobyte

b+=a;//ok

（譯者注：這個地方應該表述的有誤，其實無論a+b的值為多少，編譯器都會報錯，因為a+b操作會將a、b提升為int類型，所以將int類型賦值給byte就會編譯出錯）shorts1=1;s1=s1+1;該段代碼是否有錯,有的話怎么改？有錯誤,short類型在進行運算時會自動提升為int類型,也就是說s1+1的運算結果是int類型.shorts1=1;s1+=1;該段代碼是否有錯,有的話怎么改？+=操作符會自動對右邊的表達式結果強轉匹配左邊的數據類型,所以沒錯.&和&&的區別首先記住&是位操作,而&&是邏輯運算符.另外需要記住邏輯運算符具有短路特性,而&不具備短路特性.public

class

Test{

static

Stringname;

public

static

void

main(String[]args){

if(name!=null&userName.equals("")){

System.out.println("ok");

}else{

System.out.println("erro");

}

}

}以上代碼將會拋出空指針異常.一個.java文件內部可以有類?(非內部類)只能有一個public公共類,但是可以有多個default修飾的類.如何正確的退出多層嵌套循環.使用標號和break;通過在外層循環中添加標識符內部類的作用內部類可以有多個實例,每個實例都有自己的狀態信息,并且與其他外圍對象的信息相互獨立.在單個外圍類當中,可以讓多個內部類以不同的方式實現同一接口,或者繼承同一個類.創建內部類對象的時刻不依賴于外部類對象的創建.內部類并沒有令人疑惑的”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

calssPreCache{

static{

//執行相關操作

}

}此外static也多用于修飾內部類,此時稱之為靜態內部類.最后一種用法就是靜態導包,即importstatic.importstatic是在JDK1.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中intchar,long各占多少字節?類型位數字節數short216int432long864float432double864char21664位的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和StringBufferString和StringBuffer主要區別是性能:String是不可變對象,每次對String類型進行操作都等同于產生了一個新的String對象,然后指向新的String對象.所以盡量不在對String進行大量的拼接操作,否則會產生很多臨時對象,導致GC開始工作,影響系統性能.StringBuffer是對對象本身操作,而不是產生新的對象,因此在有大量拼接的情況下,我們建議使用StringBuffer.但是需要注意現在JVM會對String拼接做一定的優化:

Strings=“Thisisonly”+”simple”+”test”會被虛擬機直接優化成Strings=“Thisisonlysimpletest”,此時就不存在拼接過程.StringBuffer和StringBuilderStringBuffer是線程安全的可變字符串,其內部實現是可變數組.StringBuilder是jdk1.5新增的,其功能和StringBuffer類似,但是非線程安全.因此,在沒有多線程問題的前提下,使用StringBuilder會取得更好的性能.什么是編譯器常量?使用它有什么風險?公共靜態不可變（publicstaticfinal）變量也就是我們所說的編譯期常量，這里的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.分代回收

更詳細的內容參見深入理解垃圾回收算法：/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接口可能更優.原因有二:Java不支持多繼承.因此擴展Thread類就代表這個子類不能擴展其他類.而實現Runnable接口的類還可能擴展另一個類.類可能只要求可執行即可,因此繼承整個Thread類的開銷過大.Thread類中的start()和run()方法有什么區別?start()方法被用來啟動新創建的線程，而且start()內部調用了run()方法，這和直接調用run()方法的效果不一樣。當你調用run()方法的時候，只會是在原來的線程中調用，沒有新的線程啟動，start()方法才會啟動新線程。怎么檢測一個線程是否持有對象監視器Thread類提供了一個holdsLock(Objectobj)方法，當且僅當對象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讓其他線程可以占用CPUsleep(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操作的應該是對象頭中markword.FutureTask是什么這個其實前面有提到過，FutureTask表示一個異步運算的任務。FutureTask里面可以傳入一個Callable的具體實現類，可以對這個異步運算的任務的結果進行等待獲取、判斷是否已經完成、取消任務等操作。當然，由于FutureTask也是Runnable接口的實現類，所以FutureTask也可以放入線程池中。一個線程如果出現了運行時異常怎么辦?如果這個異常沒有被捕獲的話，這個線程就停止執行了。另外重要的一點是：如果這個線程持有某個某個對象的監視器，那么這個對象監視器會被立即釋放Java當中有哪幾種鎖自旋鎖:自旋鎖在JDK1.6之后就默認開啟了。基于之前的觀察，共享數據的鎖定狀態只會持續很短的時間，為了這一小段時間而去掛起和恢復線程有點浪費，所以這里就做了一個處理，讓后面請求鎖的那個線程在稍等一會，但是不放棄處理器的執行時間，看看持有鎖的線程能否快速釋放。為了讓線程等待，所以需要讓線程執行一個忙循環也就是自旋操作。在jdk6之后，引入了自適應的自旋鎖，也就是等待的時間不再固定了，而是由上一次在同一個鎖上的自旋時間及鎖的擁有者狀態來決定偏向鎖:在JDK1.之后引入的一項鎖優化，目的是消除數據在無競爭情況下的同步原語。進一步提升程序的運行性能。偏向鎖就是偏心的偏，意思是這個鎖會偏向第一個獲得他的線程，如果接下來的執行過程中，改鎖沒有被其他線程獲取，則持有偏向鎖的線程將永遠不需要再進行同步。偏向鎖可以提高帶有同步但無競爭的程序性能，也就是說他并不一定總是對程序運行有利，如果程序中大多數的鎖都是被多個不同的線程訪問，那偏向模式就是多余的，在具體問題具體分析的前提下，可以考慮是否使用偏向鎖。輕量級鎖:為了減少獲得鎖和釋放鎖所帶來的性能消耗，引入了“偏向鎖”和“輕量級鎖”，所以在JavaSE1.6里鎖一共有四種狀態，無鎖狀態，偏向鎖狀態，輕量級鎖狀態和重量級鎖狀態，它會隨著競爭情況逐漸升級。鎖可以升級但不能降級，意味著偏向鎖升級成輕量級鎖后不能降級成偏向鎖如何在兩個線程間共享數據通過在線程之間共享對象就可以了，然后通過wait/notify/notifyAll、await/signal/signalAll進行喚起和等待，比方說阻塞隊列BlockingQueue就是為線程之間共享數據而設計的如何正確的使用wait()?使用if還是while?wait()方法應該在循環調用，因為當線程獲取到CPU開始執行的時候，其他條件可能還沒有滿足，所以在處理前，循環檢測條件是否滿足會更好。下面是一段標準的使用wait和notify方法的代碼：synchronized

(obj){

while

(conditiondoesnothold)

obj.wait();

//(Releaseslock,andreacquiresonwakeup)

...

//Performactionappropriatetocondition

}什么是線程局部變量ThreadLocal線程局部變量是局限于線程內部的變量，屬于線程自身所有，不在多個線程間共享。Java提供ThreadLocal類來支持線程局部變量，是一種實現線程安全的方式。但是在管理環境下（如web服務器）使用線程局部變量的時候要特別小心，在這種情況下，工作線程的生命周期比任何應用變量的生命周期都要長。任何線程局部變量一旦在工作完成后沒有釋放，Java應用就存在內存泄露的風險。ThreadLoal的作用是什么?簡單說ThreadLocal就是一種以空間換時間的做法在每個Thread里面維護了一個ThreadLocal.ThreadLocalMap把數據進行隔離，數據不共享，自然就沒有線程安全方面的問題了.生產者消費者模型的作用是什么?（1）通過平衡生產者的生產能力和消費者的消費能力來提升整個系統的運行效率，這是生產者消費者模型最重要的作用

（2）解耦，這是生產者消費者模型附帶的作用，解耦意味著生產者和消費者之間的聯系少，聯系越少越可以獨自發展而不需要收到相互的制約寫一個生產者-消費者隊列可以通過阻塞隊列實現,也可以通過wait-notify來實現.使用阻塞隊列來實現//消費者

public

class

Producer

implements

Runnable{

private

finalBlockingQueue<Integer>

queue;

public

Producer(BlockingQueueq){

this.queue=q;

}

@Override

public

void

run()

{

try

{

while

(true){

Thread.sleep(1000);//模擬耗時

queue.put(produce());

}

}catch

(InterruptedExceptione){

}

}

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

finalBlockingQueue<Integer>

queue;

public

Consumer(BlockingQueueq){

this.queue=q;

}

@Override

public

void

run()

{

while

(true){

try

{

Thread.sleep(2000);//模擬耗時

consume(queue.take());

}catch

(InterruptedExceptione){

}

}

}

private

void

consume(Integern)

{

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

Producerp=new

Producer(queue);

Consumerc1=new

Consumer(queue);

Consumerc2=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控制權的一種操作。什么是CASCAS，全稱為CompareandSwap，即比較-替換。假設有三個操作數：內存值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在jdk1.6和jdk1.8實現原理是不同的.jdk1.6:ConcurrentHashMap是線程安全的，但是與Hashtablea相比，實現線程安全的方式不同。Hashtable是通過對hash表結構進行鎖定，是阻塞式的，當一個線程占有這個鎖時，其他線程必須阻塞等待其釋放鎖。ConcurrentHashMap是采用分離鎖的方式，它并沒有對整個hash表進行鎖定，而是局部鎖定，也就是說當一個線程占有這個局部鎖時，不影響其他線程對hash表其他地方的訪問。

具體實現:ConcurrentHashMap內部有一個Segmentjdk1.8在jdk8中，ConcurrentHashMap不再使用Segment分離鎖，而是采用一種樂觀鎖CAS算法來實現同步問題，但其底層還是“數組+鏈表->紅黑樹”的實現。CyclicBarrier和CountDownLatch區別這兩個類非常類似，都在java.util.concurrent下，都可以用來表示代碼運行到某個點上，二者的區別在于：CyclicBarrier的某個線程運行到某個點上之后，該線程即停止運行，直到所有的線程都到達了這個點，所有線程才重新運行；CountDownLatch則不是，某線程運行到某個點上之后，只是給某個數值-1而已，該線程繼續運行CyclicBarrier只能喚起一個任務，CountDownLatch可以喚起多個任務CyclicBarrier可重用，CountDownLatch不可重用，計數值為0該CountDownLatch就不可再用了java中的++操作符線程安全么?不是線程安全的操作。它涉及到多個指令，如讀取變量值，增加，然后存儲回內存，這個過程可能會出現多個線程交差你有哪些多線程開發良好的實踐?給線程命名最小化同步范圍優先使用volatile盡可能使用更高層次的并發工具而非wait和notify()來實現線程通信,如BlockingQueue,Semeaphore優先使用并發容器而非同步容器.考慮使用線程池關于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修復符的另一個作用是提供內存屏障（memorybarrier），例如在分布式框架中的應用。簡單的說，就是當你寫一個volatile變量之前，Java內存模型會插入一個寫屏障（writebarrier），讀一個volatile變量之前，會插入一個讀屏障（readbarrier）。意思就是說，在你寫一個volatile域時，能保證任何線程都能看到你寫的值，同時，在寫之前，也能保證任何數值的更新對所有線程是可見的，因為內存屏障會將其他所有寫的值更新到緩存。volatile類型變量提供什么保證?volatile主要有兩方面的作用:1.避免指令重排2.可見性保證.例如，JVM或者JIT為了獲得更好的性能會對語句重排序，但是volatile類型變量即使在沒有同步塊的情況下賦值也不會與其他語句重排序。volatile提供happens-before的保證，確保一個線程的修改能對其他線程是可見的。某些情況下，volatile還能提供原子性，如讀64位數據類型，像long和double都不是原子的(低32位和高32位)，但volatile類型的double和long就是原子的.關于集合Java中的集合及其繼承關系關于集合的體系是每個人都應該爛熟于心的,尤其是對我們經常使用的List,Map的原理更該如此.這里我們看這張圖即可:

更多內容可見集合類總結：/postedit/40826423poll()方法和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有什么區別?Array可以容納基本類型和對象，而ArrayList只能容納對象。Array是指定大小的，而ArrayList大小是固定的ArrayList和HashMap默認大小?在Java7中，ArrayList的默認大小是10個元素，HashMap的默認大小是16個元素（必須是2的冪）。這就是Java7中ArrayList和HashMap類的代碼片段private

static

final

int

DEFAULT_CAPACITY=

10;

//fromHashMap.javaJDK7

static

final

int

DEFAULT_INITIAL_CAPACITY=

1

<<

4;

//aka16Comparator和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是AndroidSDK中提供的,非Android開發者可以略過.

ArrayMap是用兩個數組來模擬map,更少的內存占用空間,更高的效率.

具體參考這篇文章:ArrayMapVSHashMap：/?p=217%5DHashMap的實現原理1HashMap概述：HashMap是基于哈希表的Map接口的非同步實現。此實現提供所有可選的映射操作，并允許使用null值和null鍵。此類不保證映射的順序，特別是它不保證該順序恒久不變。

2HashMap的數據結構：在java編程語言中，最基本的結構就是兩種，一個是數組，另外一個是模擬指針（引用），所有的數據結構都可以用這兩個基本結構來構造的，HashMap也不例外。HashMap實際上是一個“鏈表散列”的數據結構，即數組和鏈表的結合體。當我們往Hashmap中put元素時,首先根據key的hashcode重新計算hash值,根絕hash值得到這個元素在數組中的位置(下標),如果該數組在該位置上已經存放了其他元素,那么在這個位置上的元素將以鏈表的形式存放,新加入的放在鏈頭,最先加入的放入鏈尾.如果數組中該位置沒有元素,就直接將該元素放到數組的該位置上.需要注意Jdk1.8中對HashMap的實現做了優化,當鏈表中的節點數據超過八個之后,該鏈表會轉為紅黑樹來提高查詢效率,從原來的O(n)到O(logn)你了解Fail-Fast機制嗎Fail-Fast即我們常說的快速失敗,更多內容參看fail-fast機制：/chenssy/article/details/38151189Fail-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類允許你使用多種流行的格式來格式化日期。參見答案中的示例代碼，代碼中演示了將日期格式化成不同的格式，如