JavaSE面試總結

目錄

1.java的基本資料型別有哪些?

2.int和Integer的區別?

3.什么是多載和重寫？

4.==和equals的區別?

5.java中final關鍵字有哪些作用?

6.HashMap和Hashtable的區別?

7.創建執行緒的方式?

8.什么是淺拷貝與深拷貝？

9.深拷貝與淺拷貝的區別?

10.面向物件有哪些特征？

11.什么是死鎖？怎么防止死鎖？

13.swtich選擇陳述句中支持哪些資料型別？

14.什么是泛型？

15.堆疊的區別？

16.什么是執行緒同步，異步？

17.樂觀鎖和悲觀鎖的區別？

18.說一下 runnable和 callable有什么區別?

19.介面和類有什么區別和相同點？

20.執行緒的run()和start()有什么區別？

21.final 和 finally ，finalize的區別?

22.ArrayList 與 LinkedList 區別？

23.靜態變數與非靜態變數的區別?

24.什么是記憶體溢位，記憶體泄漏?

25.Throw 和 Throws 的區別?

26.JDK7 和 JDK8 區別？

27.Java 關鍵字 volatile 與 synchronized 作用與區別？

28.解決hashmap執行緒不安全問題?

29.Hashmap的底層實作原理

30.多執行緒怎么解決高并發?

31.Java中的鎖有幾種方式

32.解釋下記憶體中的堆疊、堆、方法區的用法？

33.IO和NIO的區別？

34." " 和 null的區別？

35.執行緒的狀態？

36.java的多型表現在哪里？

37.你對執行緒優先級的理解是什么？

38.Sleep()、suspend()和 wait()之間有什么區別？

39.String，StringBuilder和StringBuffer的區別?

40.什么是執行緒？？

41.執行緒和行程有什么區別？

42.有哪些不同的執行緒生命周期？

43.什么是死鎖(Deadlock)？如何分析和避免死鎖?

44. 什么是執行緒安全？Vector 是一個執行緒安全類嗎？

45.Java 中如何停止一個執行緒?

46.一個執行緒運行時發生例外會怎樣?

47.ThreadLocal 可以用來共享資料嗎?

48.什么是 Java Timer 類？如何創建一個有特定時間間隔的任務？

49.Java 中的同步集合與并發集合有什么區別？

50.同步方法和同步塊.哪個是更好的選擇？

51.什么是執行緒池？ 為什么要使用它？

52.多執行緒中的忙回圈是什么?

53.多執行緒有幾種實作方式?

54.有三個執行緒 T1，T2，T3，怎么確保它們按順序執行？

55.怎么檢測一個執行緒是否擁有鎖？

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

57.什么地方用了多執行緒?

58.Excutors 可以產生哪些執行緒池?

59.Java 中多執行緒同步是什么？

60.執行緒之間如何通信?

61.用戶執行緒和守護執行緒有什么區別?

62.如何暫停一條執行緒?

63.描述一下JVM加載class檔案的原理機制？

64.java里有什么資料結構?

65.java中break,continue,return 的區別？

66.如果hashtable存盤null值會怎么樣？

67.JVM結構原理、GC作業機制詳解?

68.TreeMap和TreeSet在排序時如何比較元素？Collections工具類中的sort()方法如何比較元素？

69.String類可以被繼承嗎？

70.& 和 && 的區別？

71.抽象類(abstract class)和介面(interface)有什么異同？

72.char 型變數中能不能存盤一個中文漢字，為什么？

73.抽象的(abstract)方法是否可同時是靜態的(static)， 是否可同時是本地方法(native)，是否可同時被 synchronized？

74.闡述靜態變數和實體變數的區別？

75.如何將一個 java 物件序列化到檔案里？

76.位元組流和字符流的區別？

77.如何實作物件克隆？

78.什么是 java 序列化，如何實作 java 序列化？

79.java執行緒池有幾種？

80.介面有什么好處？

81.Java中的變數，代碼塊，構造器之間執行的順序是怎樣的?

82.throws,throw,try,catch,finally分別代表什么意?

1.java的基本資料型別有哪些?

• 1.byte：8位，最大存盤資料量是255，存放的資料范圍是-128~127之間，

• 2.short：16位，最大資料存盤量是65536，資料范圍是-32768~32767之間，

• 3.int：32位，最大資料存盤容量是2的32次方減1，資料范圍是負的2的31次方到正的2的31次方減1，

• 4.long：64位，最大資料存盤容量是2的64次方減1，資料范圍為負的2的63次方到正的2的63次方減1，

• 5.float：32位，資料范圍在3.4e-45~1.4e38，直接賦值時必須在數字后加上f或F，

• 6.double：64位，資料范圍在4.9e-324~1.8e308，賦值時可以加d或D也可以不加，

• 7.boolean：只有true和false兩個取值，

• 8.char：16位，存盤Unicode碼，用單引號賦值，

2.int和Integer的區別?

• Int 是基本資料型別呀 Integer 是 java 為 int 提供的封裝類，是參考資料型別； Int 的默認值為 0，而 integer 的默認值為 null

3.什么是多載和重寫？

• 重寫就是父類與子類之間的多型

• 多載是在一個類中多型對的體現

• (1)方法多載是一個類中 定義了多個方法名相同,而他們的引數的數量不同或數量相同而型別和次序不同,則稱為方 法的多載(Overloading)，

• (2)方法重寫是在子類存在方法與父類的方法的名字相同,而且引數的個數與型別一樣,返 回值也一樣的方法,就稱為重寫(Overriding)，

4.==和equals的區別?

• "=="比較的是兩個字串的記憶體地址， "equals"比較的是兩個字串的實際值， == 對于簡單型別是值比較，對于物件型別是地址比較 equals 是方法，通常是比較兩個物件的 hashCode，對于字串，hashCode 是通過字串的 內容算出來的，所以間接可以比較兩個的內容

5.java中final關鍵字有哪些作用?

• 其實 Final 是一個安全修飾符,就是用 final 修飾的類不能被繼承,用 final 宣告的方法不能被重 寫,使用 final 宣告的變數就相當于常量,不能被修改，

6.HashMap和Hashtable的區別?

• 1.這兩個都是是 Map 介面下的實作類，我們開發的時候經常用的是 HashMap 雖然 HashMap 不是執行緒安全的但是他的存盤效率比較高,Hashtable 是執行緒安全我們看過他底層的 put 方法前面加的 synchronized關鍵字,但是他的效率太低,我們開發很少用，

• 2.為什么說 hashTable 是執行緒安全的? 因為看原始碼的時候里面的 put 方法前面加了 synchronized 關鍵字，

• 3.什么情況下用 hashMap? 我們有時候在自定義回傳 json 字串的時候,封裝到 List 中進行回傳，

7.創建執行緒的方式?

• 1.繼承Thread類創建線bai程子類

  • 1.在這子類中重寫run方法，在run方法內寫執行緒任務代碼

  • 2.創建該子類實體，即是創建了一個執行緒實體

  • 3.呼叫該實體的start方法來啟動該執行緒

• 2.建一個類去實作Runnable介面

  • 1.該類去實作介面的run方法，run方法內寫執行緒任務代碼

  • 2.創建該類實體，把該實體當作一個標記target傳給Thread類，如：Thread t = new Thread(該類實體)；即創建一個執行緒物件

  • 3.呼叫執行緒的star方法來啟用該執行緒

• 3.最后一種就是實作 Callable 介面

8.什么是淺拷貝與深拷貝？

• 簡單點來說，就是假設B復制了A，當修改A時，看B是否會發生變化，如果B也跟著變了，說明這是淺拷貝，拿人手短，如果B沒變，那就是深拷貝，自食其力，

9.深拷貝與淺拷貝的區別?

• 1.淺拷貝（shallowCopy）只是增加了一個指標指向已存在的記憶體地址，

• 2.深拷貝（deepCopy）是增加了一個指標并且申請了一個新的記憶體，使這個增加的指標指向這個新的記憶體，使用深拷貝的情況下，釋放記憶體的時候不會因為出現淺拷貝時釋放同一個記憶體的錯誤，

• 3.淺復制：僅僅是指向被復制的記憶體地址，如果原地址發生改變，那么淺復制出來的物件也會相應的改變，

• 4.深復制：在計算機中開辟一塊新的記憶體地址用于存放復制的物件，

10.面向物件有哪些特征？

• 1、封裝:封裝是把程序和資料包圍起來，對資料的訪問只能通過已定義的界面；面向物件計算始于這個基本概念，即現實世界可以被描繪成一系列完全自治、封裝的物件，這些物件通過一個受保護的介面訪問其他物件，

• 2、繼承:繼承是一種聯結類的層次模型，并且允許和鼓勵類的重用，它提供了一種明確表述共性的方法；物件的一個新類可以從西現有的類中派生，這個程序稱為新類的基類(也就是父類)，派生類可以從它的基類那里繼承方法和實體變數，并且類可以修改或增加新的方法使之更合適特殊的需要，

• 3、多型性：多型性是指允許不用類的物件對同一訊息做出回應，多型性包括引數化多型性和包含多型性，多型性語言具有靈活、抽象、行為共享、代碼共享的優勢，很多的解決了應用程式函式同名問題，

11.什么是死鎖？怎么防止死鎖？

• 1.執行緒死鎖是指由于兩個或者多個執行緒互相持有對方所需要的資源，導致這些執行緒處于等待狀態，無法前往執行，當執行緒進入物件的synchronized代碼塊時，便占有了資源，直到它退出該代碼塊或者呼叫wait方法，才釋放資源，在此期間，其他執行緒將不能進入該代碼塊，當執行緒互相持有對方所需要的資源時，會互相等待對方釋放資源，如果執行緒都不主動釋放所占有的資源，將產生死鎖，

• 2.從根部解決（從產生死鎖的原因入手）

  • 1、互斥使用，即當資源被一個執行緒使用(占有)時，別的執行緒不能使用

  • 2、不可搶占，資源請求者不能強制從資源占有者手中奪取資源，資源只能由資源占有者主動釋放，

  • 3、請求和保持，即當資源請求者在請求其他的資源的同時保持對原有資源的占有，

  • 4、回圈等待，即存在一個等待佇列：P1占有P2的資源，P2占有P3的資源，P3占有P1的資源，這樣就形成了一個等待環路，

• 3.有序資源分配法

• 4.銀行家演算法

13.swtich選擇陳述句中支持哪些資料型別？

• 在JDK1.5之前,switch回圈只支持byte short char int，列舉五種資料型別.

• jdk1.7開始支持String型別

14.什么是泛型？

• 我記得泛型是 JDK1.5 以后有的,我覺得使用泛型的好處就是讓我們的集合變的 更安全一些,省去了強制轉換

15.堆疊的區別？

• 1.堆記憶體用來存盤Java中的物件，無論是成員變數，區域變數，還是類變數，它們指向的物件都存盤在堆記憶體中，

• 2.堆疊記憶體用來存盤區域變數和方法呼叫，

• 3.堆疊記憶體歸屬于單個執行緒，每個執行緒都會有一個堆疊記憶體，其存盤的變數只能在其所屬執行緒中可見，即堆疊記憶體可以理解成執行緒的私有記憶體，

• 4.堆記憶體中的物件對所有執行緒可見，堆記憶體中的物件可以被所有執行緒訪問，

16.什么是執行緒同步，異步？

• 1.執行緒同步：是多個執行緒同時訪問同一資源，等待資源訪問結束，浪費時間，效率不高

• 2.執行緒異步：訪問資源時，如果有空閑時間，則可在空閑等待同時訪問其他資源，實作多執行緒機制

17.樂觀鎖和悲觀鎖的區別？

• 對于樂觀鎖和悲觀鎖的區別及應用，要牢記一句話：讀取頻繁使用樂觀鎖，寫入頻繁使用悲觀鎖

• 1.樂觀鎖假定不會發生沖突，只有在提交操作的時候檢查是否有沖突

• 2.悲觀鎖假定會發生沖突，訪問的時候都要先獲得鎖，保證同一個時刻只有執行緒獲得鎖，讀讀也會阻塞

18.說一下 runnable和 callable有什么區別?

• 1.Runnable 介面 run 方法無回傳值；Callable 介面 call 方法有回傳值，支持泛型

• 2.Runnable 介面 run 方法只能拋出運行時例外，且無法捕獲處理；Callable 介面 call 方法允許拋出例外，可以獲取例外資訊

19.介面和類有什么區別和相同點？

• 1.不同點：

  • 介面不能直接實體化，

  • 介面不包含方法的實作，

  • 介面可以多繼承，類只能單繼承，

  • 類定義可以在不同的源檔案之間進行拆分，

• 2.相同點：

  • 介面、類和結構都可以從多個介面繼承，

  • 介面類似于抽象基類：繼承介面的任何非抽象型別都必須實作介面的所有成員，

  • 介面和類都可以包含事件、索引器、屬性，

20.執行緒的run()和start()有什么區別？

• 1.呼叫 start() 方法是用來啟動執行緒的，輪到該執行緒執行時，會自動呼叫 run()；直接呼叫 run() 方法，無法達到啟動多執行緒的目的，相當于主執行緒線性執行 Thread 物件的 run() 方法，

• 2.一個執行緒對應的 start() 方法只能呼叫一次，多次呼叫會拋出 java.lang.IllegalThreadStateException 例外；run() 方法沒有限制，

21.final 和 finally ，finalize的區別?

• 1.final修飾符（關dao鍵字）如果一個類dao被宣告為final，意版味著它不能再派生出新的子類，權不能作為父類被繼承，因此一個類不能既被宣告為 abstract的，又被宣告為final的，將變數或方法宣告為final，可以保證它們在使用中不被改變，被宣告為final的變數必須在宣告時給定初值，而在以后的參考中只能讀取，不可修改，被宣告為final的方法也同樣只能使用，不能多載，

• 2.finally再例外處理時提供 finally 塊來執行任何清除操作，如果拋出一個例外，那么相匹配的 catch 子句就會執行，然后控制就會進入 finally 塊（如果有的話），

• 3.finalize方法名，Java 技術允許使用 finalize() 方法在垃圾收集器將物件從記憶體中清除出去之前做必要的清理作業，這個方法是由垃圾收集器在確定這個物件沒有被參考時對這個物件呼叫的，它是在 Object 類中定義的，因此所有的類都繼承了它，子類覆寫 finalize() 方法以整理系統資源或者執行其他清理作業，finalize() 方法是在垃圾收集器洗掉物件之前對這個物件呼叫的，

22.ArrayList 與 LinkedList 區別？

• 1.ArrayList 使用陣列方式存盤資料，所以根據索引查詢資料速度快，而新增或者 洗掉元素時需要設計到位移操作，所以比較慢，

• 2.LinkedList 使用雙向鏈接方式存盤資料，每個元素都記錄前后元素的指標， 所以插入、洗掉資料時只是更改前后元素的指標指向即可，速度非常快，然后通過下標查詢元素時需要從頭開始索引，所以比較慢，但是如果查詢前幾個元素或 后幾個元素速度比較快，

23.靜態變數與非靜態變數的區別?

• 1.java在類加載的程序中,再把.class檔案加載進記憶體的時候就為靜態變數在運行時資料區的方法區中分配記憶體,而且只分配一次.

• 2.非static變數每創建一個實體的時候就會在堆中被分配一次記憶體,每個實體都有一個獨立的非static變數

• 3.簡而言之,static變數屬于整個類,而不屬于任何一個實體,生命周期取決于類.非static變數,屬于實體,生命周期跟著實體走

24.什么是記憶體溢位，記憶體泄漏?

• 1.記憶體溢位 out of memory，是指程式在申請記憶體時，沒有足夠的記憶體空間供其使用，出現out of memory；比如申請了一個integer,但給它存了long才能存下的數，那就是記憶體溢位，

• 2.記憶體泄露 memory leak，是指程式在申請記憶體后，無法釋放已申請的記憶體空間，一次記憶體泄露危害可以忽略，但記憶體泄露堆積后果很嚴重，無論多少記憶體,遲早會被占光，memory leak會最侄訓導致out of memory！

25.Throw 和 Throws 的區別?

• throw 是拋出自定義例外的,throws 是在方法上拋出例外的.

26.JDK7 和 JDK8 區別？

• 我了解JDK8的新特性有:就是介面里也可添加普通的方法了,不用非得是抽象方法了, 但是必須得用default進行修飾,呼叫的時候也還是得實作這個介面以后才能呼叫,還有就 是添加了一個Lambda 運算式,讓我們遍歷集合資料的時候速度更快,我大概就知道這些, 我們目前開發也還沒用到過這些新特性,對了,還有就是JDK1.8以后的map存盤方式是1.7 的也有些區別.如果不相等則形成鏈表結構，jdk1.7后加的在前面，先加的移下，這種情 況叫碰撞，這種碰撞的情況應盡量避免，否存一個索引中鏈表的資料大量時，該索引當再 次插入一個物件時equals比較全部影響效率， 因此jdk1.8改善這種碰撞情況的出現，jdk1.8中的HashMap存盤結構是由陣列、鏈表、 紅黑樹這三種資料結構形成，紅黑樹查詢洗掉快新增慢，

27.Java 關鍵字 volatile 與 synchronized 作用與區別？

• 1.volatile

  • 它所修飾的變數不保留拷貝，直接訪問主記憶體中的，在Java記憶體模型中，有main memory，每個執行緒也有自己的memory (例如暫存器)，為了性能，一個執行緒會在自己的memory中保持要訪問的變數的副本，這樣就會出現同一個變 量在某個瞬間，在一個執行緒的memory中的值可能與另外一個執行緒memory中的值，或者main memory中的值不一致的情況， 一個變數宣告為volatile，就意味著這個變數是隨時會被其他執行緒修改的，因此不能將它cache在執行緒memory中，

• 2.synchronized

  • 當它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一時刻最多只有一個執行緒執行該段代碼，

• 區別：

  • 一、volatile是變數修飾符，而synchronized則作用于一段代碼或方法，

  • 二、volatile只是在執行緒記憶體和“主”記憶體間同步某個變數的值；而synchronized通過鎖定和解鎖某個監視器同步所有變數的值，顯然synchronized要比volatile消耗更多資源，

28.解決hashmap執行緒不安全問題?

• 可以通過 collections 集合工具類對不安全的執行緒進行包裝，使其變成執行緒安全的，也可以 在使用其時加 synchronized 關鍵字進行同步

29.Hashmap的底層實作原理

• 這個我在論壇上看過,Hashmap 底層是通過陣列和鏈接聯合實作的，當我們創建 hashmap 時 會先創建一個陣列，當我們用 put 方法存資料時，先根據 key 的 hashcode 值計算出 hash 值，然后用這個哈希值確定在陣列中的位置，再把 value 值放進去，如果這個位置本來沒放 東西，就會直接放進去，如果之前就有，就會生成一個鏈表，把新放入的值放在頭部，當用 get 方法取值時，會先根據 key 的 hashcode 值計算出 hash 值，確定位置，再根據 equals 方法從該位置上的鏈表中取出該 value 值，

30.多執行緒怎么解決高并發?

• 1.synchronized 關鍵字主要解決多執行緒共享資料同步問題，

• 2.ThreadLocal 使用場合主要解決多執行緒中資料因并發產生不一致問題，

• 3.ThreadLocal 和 Synchonized 都用于解決多執行緒并發訪問但是 ThreadLocal 與 synchronized 有本質的區別:

  • （1）synchronized 是利用鎖的機制，使變數或代碼塊在某一時該只能被一個執行緒訪問，

  • （2） ThreadLocal 是為每一個執行緒都提供了變數的副本，使得每個執行緒在某一時間訪問到的并 不是同一個物件，這樣就隔離了多個執行緒對資料的資料共享，而 Synchronized 卻正好相反， 它用于在多個執行緒間通信時能夠獲得資料共享，

31.Java中的鎖有幾種方式

• 兩種： Synchronized Lock

  • 1.Synchronized的局限性：

    • 1.如果這個獲取鎖的執行緒由于要等待IO或者其他原因（比如呼叫sleep方法）被阻塞了，但 是又沒有釋放鎖，其他執行緒便只能干巴巴地等待，(不能主動釋放鎖)

    • 2.當有多個執行緒讀寫檔案時，讀操作和寫操作會發生沖突現象，寫操作和寫操作會發生沖突 現象，但是讀操作和讀操作不會發生沖突現象如果多個執行緒都只是進行讀操作，所以當一個 執行緒在進行讀操作時，其他執行緒只能等待無法進行讀操作，（不分情況，一律鎖死）

  • 2.Lock 的幾個實作類 ReentrantLock是一個可重入的互斥鎖，又被稱為“獨占鎖” ReadWriteLock，顧名思義，是讀寫鎖，它維護了一對相關的鎖 — — “讀取鎖”和“寫入 鎖”，一個用于讀取操作，另一個用于寫入操作，他的兩個實作類讀鎖readerLock和寫鎖 writerLock，

32.解釋下記憶體中的堆疊、堆、方法區的用法？

• 我原來學java的時候知道JVM記憶體結構主要有三大塊：堆記憶體、方法區和堆疊，

  • 1.堆記憶體是JVM 中最大的一塊記憶體地址,它主要由年輕代和老年代還有持久代組成,所有new出來的物件都存 儲在該區域，

  • 2.堆疊就是暫存資料的地方,每個執行緒包含一個堆疊區，堆疊存放在一級快取中，存取 速度較快,堆疊中只保存基礎資料型別的物件和自定義物件的參考.每個堆疊中的資料都是私有 的，其他堆疊不能訪問，

  • 3.方法區存放了要加載的類的資訊（如類名、修飾符等）、靜態變數、 建構式、final定義的常量、類中的欄位和方法等資訊

33.IO和NIO的區別？

• 這個NIO是jdk1.7以后有的，他們兩的主要區別是：io是面向流是阻塞io，nio是面向緩沖，非阻塞的io；io的話每次從流中讀取一個或多個位元組，知道讀取完所有的位元組，沒有快取到任何地方，nio讀取的是資料是有快取的，就是說他讀取的資料是在緩沖里讀的，另外的話，java中的各種io是阻塞的，就是說一個執行緒呼叫read或者write（）時，這個執行緒就已經被阻塞了，知道讀取到一些資料為止，或者是完全寫入，在這個程序中不能干其他的事情，nio的非阻塞模式，當發送一個讀取資料的請求的時候，如果它有讀取到可用的資料，就什么也不會獲取，且不會讓執行緒阻塞寫也是這樣，非阻塞的io的空閑時間可以用來做其他的操作，所以一個單獨二非阻塞執行緒可以管理多個輸入和輸出通道，另外nio還有一個selectr（選擇器），他是可以管理多個輸入輸出的通道，我大概了解的也就是這樣

34." " 和 null的區別？

• 1.null是沒有地址

• 2." "是有地址但是里面的內容是空的

35.執行緒的狀態？

• 1.其實執行緒一般具有五種狀態，即創建（新建態）、就緒、運行、阻塞、終止

36.java的多型表現在哪里？

• 1.編譯多型：主要是體現在多載吧，系統在編譯時就能確定調度用多載函式的哪個版本，

• 2.運行時多型：主要體現在代碼設計的繼承性上，子類的物件也是父類的物件，即上溯造型，所以子類物件可以作為父類物件使用，父類的物件變數可以指向子類物件，因此通過一個父類發出的方法呼叫可能執行的是方法在父類中的實作，也可能是某個子類中的實作，它是由運行時刻具體的物件型別決定的，

37.你對執行緒優先級的理解是什么？

• 每一個執行緒都是有優先級的，一般來說，高優先級du的執行緒在運行時會具有優先權，但這依賴于執行緒調度的實作，這個實作是和作業系統相關的(OSdependent)，可以定義執行緒的優先級，但是這并不能保證高優先級的執行緒會在低優先級的執行緒前執行，執行緒優先級是一個int變數(從1-10)，1代表最低優先級，10代表最高優先級，

38.Sleep()、suspend()和 wait()之間有什么區別？

• 1.Thread.sleep()使當前執行緒在指定的時間處于“非運行”（Not Runnable）狀態，執行緒一直持有物件的監視器，比如一個執行緒當前在一個同步塊或同步方法中，其它執行緒不能進入該塊或方法中，如果另一執行緒呼叫了interrupt()方法，它將喚醒那個“睡眠的”執行緒，

• 2.sleep()是一個靜態方法，這意味著只對當前執行緒有效，一個常見的錯誤是呼叫t.sleep()，（這里的t是一個不同于當前執行緒的執行緒），即便是執行t.sleep()，也是當前執行緒進入睡眠，而不是t執行緒，t.suspend()是過時的方法，使用suspend()導致執行緒進入停滯狀態，該執行緒會一直持有物件的監視器，suspend()容易引起死鎖問題，

• 3.object.wait()使當前執行緒出于“不可運行”狀態，和sleep()不同的是wait是object的方法而不是thread，

39.String，StringBuilder和StringBuffer的區別?

• 1.String是只讀字串，所參考的字串不能被改變

• 2.Stringbuffer和Stringbuilder定義的可以通過各種方法來達到簡單的增刪改；

• 3.String和Stringbuilder在單執行緒環境下使用；

• 4.StringBuffer在多執行緒環境下使用，可以保證執行緒同步；

• 5.Stringbuilder 和StringBuffer 實作方法類似，均表示可變字符序列，不過StringBuffer 用synchronized關鍵字修飾（保證執行緒同步）

• 運行速度：Stringbuilder最快，StringBuffer次之；String最慢，因為每次都要重新開辟記憶體，產生很多匿名物件，影響系統性能，

40.什么是執行緒？？

• 執行緒是作業系統能夠進行運算調度的最小單位.它被包含在行程之中.是行程中 的實際運作單位，程式員可以通過它進行多處理器編程.你可以使用多執行緒對運算 密集型任務提速，比如.如果一個執行緒完成一個任務要 100 毫秒.那么用十個執行緒完 成改任務只需 10 毫秒，

41.執行緒和行程有什么區別？

• 執行緒是行程的子集.一個行程可以有很多執行緒.每條執行緒并行執行不同的任務， 不同的行程使用不同的記憶體空間.而所有的執行緒共享一片相同的記憶體空間，每個線 程都擁有單獨的堆疊記憶體用來存盤本地資料，

42.有哪些不同的執行緒生命周期？

• 當我們在 Java 程式中新建一個執行緒時.它的狀態是 New，當我們呼叫執行緒的 start()方法時.狀態被改變為 Runnable，執行緒調度器會為 Runnable 執行緒池中的線 程分配 CPU 時間并且講它們的狀態改變為 Running，其他的執行緒狀態還有 Waiting.Blocked 和 Dead，

43.什么是死鎖(Deadlock)？如何分析和避免死鎖?

• 死鎖是指兩個以上的執行緒永遠阻塞的情況.這種情況產生至少需要兩個以上的 執行緒和兩個以上的資源， 分析死鎖.我們需要查看 Java 應用程式的執行緒轉儲，我們需要找出那些狀態 為 BLOCKED 的執行緒和他們等待的資源，每個資源都有一個唯一的 id.用這個 id 我 們可以找出哪些執行緒已經擁有了它的物件鎖， 避免嵌套鎖.只在需要的地方使用鎖和避免無限期等待是避免死鎖的通常辦法，

44. 什么是執行緒安全？Vector 是一個執行緒安全類嗎？

• 如果你的代碼所在的行程中有多個執行緒在同時運行.而這些執行緒可能會同時運 行這段代碼，如果每次運行結果和單執行緒運行的結果是一樣的.而且其他的變數的 值也和預期的是一樣的.就是執行緒安全的，一個執行緒安全的計數器類的同一個實體 物件在被多個執行緒使用的情況下也不會出現計算失誤，很顯然你可以將集合類分成 兩組.執行緒安全和非執行緒安全的，Vector 是用同步方法來實作執行緒安全的, 而和它 相似的 ArrayList 不是執行緒安全的，

45.Java 中如何停止一個執行緒?

• Java 提供了很豐富的 API 但沒有為停止執行緒提供 API，JDK 1.0 本來有一些 像 stop(), suspend() 和 resume()的控制方法但是由于潛在的死鎖威脅因此在后續 的 JDK 版本中他們被棄用了.之后 Java API 的設計者就沒有提供一個兼容且執行緒安 全的方法來停止一個執行緒，當 run() 或者 call() 方法執行完的時候執行緒會自動結束, 如果要手動結束一個執行緒.你可以用 volatile 布爾變數來退出 run()方法的回圈或者 是取消任務來中斷執行緒

46.一個執行緒運行時發生例外會怎樣?

• 簡單的說，如果例外沒有被捕獲該執行緒將會停止執行， Thread.UncaughtExceptionHandler 是用于處理未捕獲例外造成執行緒突然中斷情況的一 個內嵌介面，當一個未捕獲例外將造成執行緒中斷的時候 JVM 會使用 Thread.getUncaughtExceptionHandler()來查詢執行緒的 UncaughtExceptionHandler 并 將執行緒和例外作為引數傳遞給 handler 的 uncaughtException()方法進行處理，

47.ThreadLocal 可以用來共享資料嗎?

• 不可以

• ThreadLocal 是采用哈希表的方式來為每個執行緒都提供一個變數的副本ThreadLocal 保證各個執行緒間資料安全，每個執行緒的資料不會被另外執行緒訪問和破壞

48.什么是 Java Timer 類？如何創建一個有特定時間間隔的任務？

• java.util.Timer 是一個工具類.可以用于安排一個執行緒在未來的某個特定時間 執行，Timer 類可以用安排一次性任務或者周期任務， java.util.TimerTask 是一個實作了 Runnable 介面的抽象類.我們需要去繼承 這個類來創建我們自己的定時任務并使用 Timer 去安排它的執行，

49.Java 中的同步集合與并發集合有什么區別？

• 1.同步集合與并發集合都為多執行緒和并發提供了合適的執行緒安全的集合.不過并 發集合的可擴展性更高，

• 2.在 Java1.5 之前程式員們只有同步集合來用且在多執行緒并發的時候會導致爭 用.阻礙了系統的擴展性，

• 3.Java5 介紹了并發集合像 ConcurrentHashMap.不僅提供執行緒安全還用鎖分 離和 內部磁區等現代技術提高了可擴展性，

50.同步方法和同步塊.哪個是更好的選擇？

• 同步塊是更好的選擇.因為它不會鎖住整個物件（當然你也可以讓它鎖住整個物件），同步方法會鎖住整個物件.哪怕這個類中有多個不相關聯的同步塊.這通常 會導致他們停止執行并需要等待獲得這個物件上的鎖，

51.什么是執行緒池？ 為什么要使用它？

• 1.創建執行緒要花費昂貴的資源和時間.如果任務來了才創建執行緒那么回應時間會 變長.而且一個行程能創建的執行緒數有限，

• 2.為了避免這些問題.在程式啟動的時候就創建若干執行緒來回應處理.它們被稱為 執行緒池.里面的執行緒叫作業執行緒，

• 3.從 JDK1.5 開始.Java API 提供了 Executor 框架讓你可以創建不同的執行緒池， 比如單執行緒池.每次處理一個任務；數目固定的執行緒池或者是快取執行緒池（一個適 合很多生存期短的任務的程式的可擴展執行緒池）

52.多執行緒中的忙回圈是什么?

• 1.忙回圈就是程式員用回圈讓一個執行緒等待.不像傳統方法 wait(), sleep() 或 yield() 它們都放棄了 CPU 控制.而忙回圈不會放棄 CPU.它就是在運行一個慷訓圈， 這么做的目的是為了保留 CPU 快取，

• 2.在多核系統中.一個等待執行緒醒來的時候可能會在另一個內核運行.這樣會重建 快取，為了避免重建快取和減少等待重建的時間就可以使用它了，

53.多執行緒有幾種實作方式?

• 1.多執行緒有兩種實作方法，分別是繼承 Thread 類與實作 Runnable 介面

• 2.執行緒同步的實作方面有五種

  • synchronized

    • 一直持有鎖，直至執行結束

  • wait

    • 使一個執行緒處于等待狀態，并且釋放所持有的物件的 lock，需捕獲例外，

  • notify

    • 使一個正在運行的執行緒處于睡眠狀態，是一個靜態方法，需捕獲例外， 不釋放鎖，

  • sleep

    • 喚醒一個處于等待狀態的執行緒，注意的是在呼叫此方法的時候，并不 能確切的喚醒某一個等待狀態的執行緒，而是由 JVM 確定喚醒哪個執行緒，而且 不是按優先級，

  • suspend

    • 喚醒所有處入等待狀態的執行緒，注意并不是給所有喚醒執行緒一個物件的 鎖，而是讓它們競爭

54.有三個執行緒 T1，T2，T3，怎么確保它們按順序執行？

• 在多執行緒中有多種方法讓執行緒按特定順序執行，你可以用執行緒類的 join()方法 在一個執行緒中啟動另一個執行緒，另外一個執行緒完成該執行緒繼續執行，為了確保 三個執行緒的順序你應該先啟動最后一個(T3呼叫 T2，T2呼叫 T1)，這樣 T1就會 先完成而 T3最后完成

55.怎么檢測一個執行緒是否擁有鎖？

• 在 java.lang.Thread 中有一個方法叫 holdsLock()，它回傳 true 如果當且僅當當 前執行緒擁有某個具體物件的鎖

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

• 你可以通過共享物件來實作這個目的，或者是使用像阻塞佇列這樣并發的資料結 構，用 wait 和 notify 方法實作了生產者消費者模型，

57.什么地方用了多執行緒?

• 下訂單這里，我們一般采用多執行緒下單，但多執行緒中我們又需要保證用戶搶單的公平性，也就是先搶先下單，我們可以這樣實作，用戶進入秒殺搶單，如果用戶符合搶單資格，只需要記錄用戶搶單資料，存入佇列，多執行緒從佇列中進行消費即可，存入佇列采用左壓，多執行緒下單采用右取的方式，

58.Excutors 可以產生哪些執行緒池?

• Java 里面執行緒池的頂級介面是 Executor，但是嚴格意義上講 Executor 并不是一個 執行緒池，而只是一個執行執行緒的工具，真正的執行緒池介面是 ExecutorService， ThreadPoolExecutor 是 Executors 類的底層實作，

59.Java 中多執行緒同步是什么？

• 即當有一個執行緒在對記憶體進行操作時，其他執行緒都不可以對這個記憶體地址進 行操作，直到該執行緒完成操作， 其他執行緒才能對該記憶體地址進行操作，而其他執行緒又 處于等待狀態

60.執行緒之間如何通信?

• 1.多個執行緒在處理同一個資源，但是處理的動作（執行緒的任務）卻不相同，通過 一定的手段使各個執行緒能有效的利用資源，

• 2.通常情況下，一個次級執行緒要為主執行緒完成某種特定型別的任務，這就隱含著表 示在主執行緒和次級執行緒之間需要建立一個通信的通道，一般情況下，有下面的幾種方 法實作這種通信任務：使用全域變數、使用事件物件、使用訊息

61.用戶執行緒和守護執行緒有什么區別?

• 1.所謂守護執行緒，是指在程式運行的時候在后臺提供一種通用服務的執行緒，比如 垃圾回收執行緒就是一個很稱職的守護者，并且這種執行緒并不屬于程式中不可或缺的部 分，因此，當所有的非守護執行緒結束時，程式也就終止了，同時會殺死行程中的所有 守護執行緒，反過來說，只要任何非守護執行緒還在運行，程式就不會終止，

• 2.用戶執行緒和守護執行緒兩者幾乎沒有區別，唯一的不同之處就在于虛擬機的離開： 如果用戶執行緒已經全部退出運行了，只剩下守護執行緒存在了，虛擬機也就退出了，因 為沒有了被守護者，守護執行緒也就沒有作業可做了，也就沒有繼續運行程式的必要了

62.如何暫停一條執行緒?

• 兩種方式暫停一條執行緒，一個是采取 Thread 類的 sleep()方法,一個是在同步代碼 中使用 wait()方法.

63.描述一下JVM加載class檔案的原理機制？

• Java中的所有類，都需要由類加載器裝載到JVM中才能運行，類加載器本身也是一個類，而它的作業就是把class檔案從硬碟讀取到記憶體中，在寫程式的時候，我們幾乎不需要關心類的加載，因為這些都是隱式裝載的，除非我們有特殊的用法，像是反射，就需要顯式的加載所需要的類，

• 類加載方式，有兩種 ：

  • 1、隱式裝載， 程式在運行程序中當碰到通過new 等方式生成物件時，隱式呼叫類裝載器加載對應的類到jvm中，

  • 2、顯式裝載， 通過class.forname()等方法，顯式加載需要的類Java類的加載是動態的，它并不會一次性將所有類全部加載后再運行，而是保證程式運行的基礎類(像是基類)完全加載到jvm中，至于其他類，則在需要的時候才加載，這當然就是為了節省記憶體開銷

64.java里有什么資料結構?

• Java中有幾種常用的資料結構，主要分為Collection和map兩個主要介面（介面只提供方法，并不提供實作），而程式中最終使用的資料結構是繼承自這些介面的資料結構類，

• 資料結構實作類及區別 ：

  • 1．ArrayList: 元素單個，效率高，多用于查詢

  • 2．Vector: 元素單個，執行緒安全，多用于查詢

  • 3．LinkedList:元素單個，多用于插入和洗掉

  • 4．HashMap: 元素成對，元素可為空

  • 5．HashTable: 元素成對，執行緒安全，元素不可為空

65.java中break,continue,return 的區別？

• 1.break默認是跳出最里層的回圈，也就是break所在的最近的那層回圈

• 2.continue是終止本次回圈，繼續下次回圈

• 3.return 結束當前方法

66.如果hashtable存盤null值會怎么樣？

• 編譯會通過

• 運行時會報空指標例外的錯誤

67.JVM結構原理、GC作業機制詳解?

• JVM主要包括四個部分：

  • 1.類加載器（ClassLoader）

    • 在JVM啟動時或者在類運行時將需要的class加載到JVM中，

  • 2.執行引擎

    • 負責執行class檔案中包含的位元組碼指令

  • 3.本地方法介面

    • 主要是呼叫C或C++實作的本地方法及回傳結果，

  • 4.記憶體區（也叫運行時資料區）

    • 是在JVM運行的時候操作所分配的記憶體區，運行時記憶體區主要可以劃分為5個區域:堆，堆疊，方法區，程式計數器，本地方法堆疊

• GC作業機制

68.TreeMap和TreeSet在排序時如何比較元素？Collections工具類中的sort()方法如何比較元素？

• 1.TreeSet要求存放的物件所屬的類必須實作Comparable介面，該介面提供了比較元素的compareTo()方法，當插入元素時會回呼該方法比較元素的大小，

• 2.TreeMap要求存放的鍵值對映射的鍵必須實作Comparable介面從而根據鍵對元素進行排序，

• 3.Collections工具類的sort方法有兩種多載的形式，第一種要求傳入的待排序容器中存放的物件必須實作Comparable介面以實作元素的比較；第二種不強制性的要求容器中的元素必須可比較，但是要求傳入第二個引數，引數是Comparator介面的子型別（需要重寫compare方法實作元素的比較），相當于一個臨時定義的排序規則，其實就是通過介面注入比較元素大小的演算法，也是對回呼模式的應用（Java中對函式式編程的支持），

69.String類可以被繼承嗎？

• String類在宣告時使用final關鍵字修飾，被final關鍵字修飾的類無法被繼承，

70.& 和 && 的區別？

• &運算子是：邏輯與；&&運算子是：短路與，

• 1.&和&&在程式中最終的運算結果是完全一致的，只不過&&存在短路現象，當&&運算子左邊的運算式結果為false的時候，右邊的運算式不執行，此時就發生了短路現象，如果是&運算子，那么不管左邊的運算式是true還是false，右邊運算式是一定會執行的，這就是他們倆的本質區別，

• 1. 當然，&運算子還可以使用在二進制位運算上，例如按位與操作，

71.抽象類(abstract class)和介面(interface)有什么異同？

• 不同點：

  • 1.抽象類中可以定義構造器，介面不能；

  • 2.抽象類可以有抽象方法和具體方法，介面不能有具體方法；

  • 3.介面中的成員全都是 public 的，抽象類中的成員可以使用private、public、protected、默認等修飾；

  • 4.抽象類中可以定義成員變數，介面中只能是常量；

  • 5.有抽象方法的類必須被宣告為抽象類，而抽象類未必要有抽象方法；

  • 6.抽象類中可以包含靜態方法，介面中不能有靜態方法；

  • 7.一個類只能繼承一個抽象類，一個類可以實作多個介面；

• 相同點：

  • 1.都不能夠實體化；

  • 2.可以將抽象類和介面型別作為參考型別；

  • 3.一個類如果繼承了某個抽象類或者實作了某個介面都需要對其中的抽象方法全部進行實作，否則該類仍然需要被宣告為抽象類；

72.char 型變數中能不能存盤一個中文漢字，為什么？

• char 型別可以存盤一個中文漢字，因為Java中使用的編碼是Unicode（不選擇任何特定的編碼，直接使用字符在字符集中的編號，這是統一的唯一方法），一個char 型別占2個位元組（16 位元），所以放一個中文是沒問題的，

73.抽象的(abstract)方法是否可同時是靜態的(static)， 是否可同時是本地方法(native)，是否可同時被 synchronized？

• 都不能，

• 1.抽象方法需要子類重寫，而靜態的方法是無法被重寫的，因此二者是矛盾的，

• 2.本地方法是由本地代碼（如 C++ 代碼）實作的方法，而抽象方法是沒有實作的，也是矛盾的，

• 3.synchronized 和方法的實作細節有關，抽象方法不涉及實作細節，因此也是相互矛盾的，

74.闡述靜態變數和實體變數的區別？

• 不管創建多少個物件，靜態變數在記憶體中有且僅有一個；

• 實體變數必須依存于某一實體，需要先創建物件然后通過物件才能訪問到它，

• 靜態變數可以實作讓多個物件共享記憶體，

75.如何將一個 java 物件序列化到檔案里？

• 在 java 中能夠被序列化的類必須先實作 Serializable 介面，該介面沒有任何抽象方法只是起到一個標記作用，

76.位元組流和字符流的區別？

• 位元組流讀取的時候，讀到一個位元組就回傳一個位元組；字符流使用了位元組流讀到一個或多個位元組（中文對應的位元組數是兩個，在 UTF-8 碼表中是 3 個位元組）時，先去查指定的編碼表，將查到的字符回傳，位元組流可以處理所有型別資料，如：圖片，MP3，AVI視頻檔案，而字符流只能處理字符資料，只要是處理純文本資料，就要優先考慮使用字符流，除此之外都用位元組流，位元組流主要是操作 byte 型別資料，以 byte 陣列為準，主要操作類就是 OutputStream、InputStream字符流處理的單元為 2 個位元組的 Unicode 字符，分別操作字符、字符陣列或字串，而位元組流處理單元為 1 個位元組，操作位元組和位元組陣列，所以字符流是由 Java 虛擬機將位元組轉化為 2 個位元組的 Unicode 字符為單位的字符而成的，所以它對多國語言支持性比較好！如果是音頻檔案、圖片、歌曲，就用位元組流好點，如果是關系到中文（文本）的，用字符流好點，在程式中一個字符等于兩個位元組，java 提供了 Reader、Writer 兩個專門操作字符流的類，

77.如何實作物件克隆？

• 有兩種方式：

  • 1.實作 Cloneable 介面并重寫 Object 類中的 clone()方法；

  • 2.實作 Serializable 介面，通過物件的序列化和反序列化實作克隆，可以實作真正的深度克隆

78.什么是 java 序列化，如何實作 java 序列化？

• 序列化就是一種用來處理物件流的機制，所謂物件流也就是將物件的內容進行流化，可以對流化后的物件進行讀寫操作，也可將流化后的物件傳輸于網路之間，序列化是為了解決在對物件流進行讀寫操作時所引發的問題，序 列 化 的 實 現 ： 將 需 要 被 序 列 化 的 類 實 現 Serializable 接 口 ， 該 接 口 沒 有 需 要 實 現 的 方 法 ， implements Serializable 只是為了標注該物件是可被序列化的，然后使用一個輸出流(如：FileOutputStream)來構造一個 ObjectOutputStream(物件流)物件，接著，使用 ObjectOutputStream 物件的 writeObject(Object obj)方法就可以將引數為 obj 的物件寫出(即保存其狀態)，要恢復的話則用輸入流，

79.java執行緒池有幾種？

• 一：newCachedThreadPool（快取執行緒型池）

  • (1)快取型池子，先查看池中有沒有以前建立的執行緒，如果有，就reuse，如果沒有，就建立一個新的執行緒加入池中；

  • (2)快取型池子，通常用于執行一些生存周期很短的異步型任務；因此一些面向連接的daemon型server中用得不多；

  • (3)能reuse的執行緒，必須是timeout IDLE內的池中執行緒，預設timeout是60s,超過這個IDLE時長，執行緒實體將被終止及移出池，

  • (4)注意，放入CachedThreadPool的執行緒不必擔心其結束，超過TIMEOUT不活動，其會自動被終止

• 二：newFixedThreadPool （快取執行緒池和上面的差不多）

  • (1)newFixedThreadPool與cacheThreadPool差不多，也是能reuse就用，但不能隨時建新的執行緒

  • (2)其獨特之處:任意時間點，最多只能有固定數目的活動執行緒存在，此時如果有新的執行緒要建立，只能放在另外的佇列中等待，直到當前的執行緒中某個執行緒終止直接被移出池子

  • (3)和cacheThreadPool不同，FixedThreadPool沒有IDLE機制（可能也有，但既然檔案沒提，肯定非常長，類似依賴上層的TCP或UDP IDLE機制之類的），所以FixedThreadPool多數針對一些很穩定很固定的正規并發執行緒，多用于服務器

  • (4)從方法的源代碼看，cache池和fixed 池呼叫的是同一個底層池，只不過引數不同

    • fixed池執行緒數固定，并且是0秒IDLE（無IDLE

    • cache池執行緒數支持0-Integer.MAX_VALUE(顯然完全沒考慮主機的資源承受能力），60秒IDLE

• 三：ScheduledThreadPool（調度型執行緒池）

  • （1）調度型執行緒池

  • （2）這個池子里的執行緒可以按schedule依次delay執行，或周期執行

• 四：SingleThreadExecutor（單例執行緒）

  • （1）單例執行緒，任意時間池中只能有一個執行緒

  • 2）用的是和cache池和fixed池相同的底層池，但執行緒數目是1-1,0秒IDLE（無IDLE）

80.介面有什么好處？

• 1.重要性：在Java語言中， abstract class 和interface 是支持抽象類定義的兩種機制，正是由于這兩種機制的存在，才賦予了Java強大的 面向物件能力，

• 2、簡單、規范性：如果一個專案比較龐大，那么就需要一個能理清所有業務的架構師來定義一些主要的介面，這些介面不僅告訴開發人員你需要實作那些業務，而且也將命名規范限制住了（防止一些開發人員隨便命名導致別的程式員無法看明白），

• 3.維護、拓展性：比如你要做一個畫板程式，其中里面有一個面板類，主要負責繪畫功能，然后你就這樣定義了這個類，可是在不久將來，你突然發現這個類滿足不了你了，然后你又要重新設計這個類，更糟糕是你可能要放棄這個類，那么其他地方可能有參考他，這樣修改起來很麻煩，如果你一開始定義一個介面，把繪制功能放在介面里，然后定義類時實作這個介面，然后你只要用這個介面去參考實作它的類就行了，以后要換的話只不過是參考另一個類而已，這樣就達到維護、拓展的方便性，

• 4.安全、嚴密性：介面是實作軟體松耦合的重要手段，它描敘了系統對外的所有服務，而不涉及任何具體的實作細節，這樣就比較安全、嚴密一些（一般軟體服務商考慮的比較多），

81.Java中的變數，代碼塊，構造器之間執行的順序是怎樣的?

• 步驟：

  • 1、父類靜態變數和靜態代碼塊（先宣告的先執行）；

  • 2、子類靜態變數和靜態代碼塊（先宣告的先執行）；

  • 3、父類的變數和代碼塊（先宣告的先執行）；

  • 4、父類的建構式；

  • 5、子類的變數和代碼塊（先宣告的先執行）；

  • 6、子類的建構式，

82.throws,throw,try,catch,finally分別代表什么意?

• 1.try – 用于監聽，將要被監聽的代碼(可能拋出例外的代碼)放在try陳述句塊之內，當try陳述句塊內發生例外時，例外就被拋出，

• 2.catch – 用于捕獲例外，catch用來捕獲try陳述句塊中發生的例外，

• 3.finally – finally陳述句塊總是會被執行，它主要用于回收在try塊里打開的物力資源(如資料庫連接、網路連接和磁盤檔案)，只有finally塊，執行完成之后，才會回來執行try或者catch塊中的return或者throw陳述句，如果finally中使用了return或者throw等終止方法的陳述句，則就不會跳回執行，直接停止，

• 4.throw – 用于拋出例外，

• 5.throws – 用在方法簽名中，用于宣告該方法可能拋出的例外