Java經典面試題詳解，突圍金九銀十面試季（附詳細答案）

前言：

想在面試、作業中脫穎而出？想在最短的時間內快速掌握 Java 的核心基礎知識點？想要成為一位優秀的 Java 工程師？本篇文章能助你一臂之力！

金九銀十，目前正值招聘求職旺季，很多同學對一些新技術名詞都能侃侃而談，但對一些核心原理理解的不夠透徹，特別是對 Java的一些核心基礎知識點掌握的不夠，例如JVM、常用的演算法和資料結構等，正所謂萬丈高樓平地起，只有把基礎掌握的牢固，才能走的更遠，面對不斷更新的技術才能快速掌握，同時在面試、作業中也更能脫穎而出！

下方面試題我只挑選了幾個比較好的，剩余的實在是太多了寫不完，都整理成筆記了，想要筆記的可以點擊下方群號領取，另外本人整理收藏了20年多家公司面試知識點整理 ，以及各種Java核心知識點免費分享給大家，下方只是部分截圖 想要資料的話也可以點擊795983544領取 暗號CSDN，

1.Java 自動裝箱與拆箱

裝箱就是自動將基本資料型別轉換為包裝器型別（int–>Integer）；呼叫方法：Integer 的 valueOf(int) 方法

拆箱就是自動將包裝器型別轉換為基本資料型別（Integer–>int），呼叫方法：Integer 的 intValue 方法

在 Java SE5 之前，如果要生成一個數值為 10 的 Integer 物件，必須這樣進行：

Integer i = new Integer(10);

而在從 Java SE5 開始就提供了自動裝箱的特性，如果要生成一個數值為 10 的 Integer 物件，只需要這

樣就可以了：

Integer i = 10;

2.多載和重寫的區別

重寫(Override)

從字面上看，重寫就是 重新寫一遍的意思，其實就是在子類中把父類本身有的方法重新寫一遍，子類繼承了父類原有的方法，但有時子類并不想原封不動的繼承父類中的某個方法，所以在方法名，引數串列，回傳型別(除過子類中方法的回傳值是父類中方法回傳值的子類時)都相同的情況下， 對方法體進行修改或重寫，這就是重寫，但要注意子類函式的訪問修飾權限不能少于父類的，

public class Father {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Son s = new Son();
        s.sayHello();
    }
    public void sayHello() {
        System.out.println("Hello");
    }
}
class Son extends Father{
    @Override
    public void sayHello() {
        // TODO Auto-generated method stub
        System.out.println("hello by ");
    }
}

重寫 總結：

（1）發生在父類與子類之間

（2）方法名，引數串列，回傳型別（除過子類中方法的回傳型別是父類中回傳型別的子類）必須相同

（3）訪問修飾符的限制一定要大于被重寫方法的訪問修飾符（public>protected>default>private)

（4）重寫方法一定不能拋出新的檢查例外或者比被重寫方法申明更加寬泛的檢查型例外

多載（Overload）

在一個類中，同名的方法如果有不同的引數串列（引數型別不同、引數個數不同甚至是引數順序不同）

則視為多載，同時，多載對回傳型別沒有要求，可以相同也可以不同，但不能通過回傳型別是否相同來

判斷多載，

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Father s = new Father();
    s.sayHello();
    s.sayHello("wintershii");
}
public void sayHello() {
    System.out.println("Hello");
}
public void sayHello(String name) {
    System.out.println("Hello" + " " + name);
}
}

多載 總結：

（1）多載 Overload 是一個類中多型性的一種表現

（2）多載要求同名方法的引數串列不同(引數型別，引數個數甚至是引數順序)

（3）多載的時候，回傳值型別可以相同也可以不相同，無法以回傳型別作為多載函式的區分標準

3.equals 與==的區別

== ：

== 比較的是變數(堆疊)記憶體中存放的物件的(堆)記憶體地址，用來判斷兩個物件的地址是否相同，即是否是指相同一個物件，比較的是真正意義上的指標操作，

（1）比較的是運算子兩端的運算元是否是同一個物件，

（2）兩邊的運算元必須是同一型別的（可以是父子類之間）才能編譯通過，

（3）比較的是地址，如果是具體的阿拉伯數字的比較，值相等則為 true，如：

int a=10 與 long b=10L 與 double c=10.0 都是相同的（為 true），因為他們都指向地址為 10 的堆，

equals：

equals 用來比較的是兩個物件的內容是否相等，由于所有的類都是繼承自 java.lang.Object 類的，所以適用于所有物件，如果沒有對該方法進行覆寫的話，呼叫的仍然是 Object 類中的方法，而 Object 中的 equals 方法回傳的卻是==的判斷，

總結：

所有比較是否相等時，都是用 equals 并且在對常量相比較時，把常量寫在前面，因為使用 object 的 equals object 可能為 null 則空指標在阿里的代碼規范中只使用 equals ，阿里插件默認會識別，并可以快速修改，推薦安裝阿里插件來排查老代碼使用“==”，替換成 equals

4. Hashcode 的作用

java 的集合有兩類，一類是 List，還有一類是 Set，前者有序可重復，后者無序不重復，當我們在 set 中插入的時候怎么判斷是否已經存在該元素呢，可以通過 equals 方法，但是如果元素太多，用這樣的方法就會比較滿，

于是有人發明了哈希演算法來提高集合中查找元素的效率， 這種方式將集合分成若干個存盤區域，每個物件可以計算出一個哈希碼，可以將哈希碼分組，每組分別對應某個存盤區域，根據一個物件的哈希碼就可以確定該物件應該存盤的那個區域，

hashCode 方法可以這樣理解：它回傳的就是根據物件的記憶體地址換算出的一個值，這樣一來，當集合要添加新的元素時，先呼叫這個元素的 hashCode 方法，就一下子能定位到它應該放置的物理位置上，如果這個位置上沒有元素，它就可以直接存盤在這個位置上，不用再進行任何比較了；如果這個位置上已經有元素了，就呼叫它的 equals 方法與新元素進行比較，相同的話就不存了，不相同就散列其它的地址，這樣一來實際呼叫 equals 方法的次數就大大降低了，幾乎只需要一兩次，

5.String、String StringBu?er 和 StringBuilder 的區別是什么?

String 是只讀字串，它并不是基本資料型別，而是一個物件，從底層原始碼來看是一個?nal 型別的字符陣列，所參考的字串不能被改變，一經定義，無法再增刪改，每次對 String 的操作都會生成新的 String 物件，

private final char value[];

每次+操作 ： 隱式在堆上 new 了一個跟原字串相同的 StringBuilder 物件，再呼叫 append 方法 拼接+后面的字符，

StringBu?er 和 StringBuilder 他們兩都繼承了 AbstractStringBuilder 抽象類，從 AbstractStringBuilder 抽象類中我們可以看到，

/**
* The value is used for character storage.
*/
char[] value;

他們的底層都是可變的字符陣列，所以在進行頻繁的字串操作時，建議使用 StringBu?er 和 StringBuilder 來進行操作， 另外 StringBu?er 對方法加了同步鎖或者對呼叫的方法加了同步鎖，所以是執行緒安全的，StringBuilder 并沒有對方法進行加同步鎖，所以是非執行緒安全的，

6.ArrayList 和 linkedList 的區別

Array（陣列）是基于索引(index)的資料結構，它使用索引在陣列中搜索和讀取資料是很快的，

Array 獲取資料的時間復雜度是 O(1),但是要洗掉資料卻是開銷很大，因為這需要重排陣列中的所有資料,(因為洗掉資料以后, 需要把后面所有的資料前移)

缺點: 陣列初始化必須指定初始化的長度, 否則報錯

例如:

int[] a = new int[4];
//推介使用 int[] 這種方式初始化
int c[] = {23,43,56,78};
//長度：4，索引范圍：[0,3]

List—是一個有序的集合，可以包含重復的元素，提供了按索引訪問的方式，它繼承 Collection，

List 有兩個重要的實作類：ArrayList 和 LinkedList

ArrayList: 可以看作是能夠自動增長容量的陣列

ArrayList 的 toArray 方法回傳一個陣列

ArrayList 的 asList 方法回傳一個串列

ArrayList 底層的實作是 Array, 陣列擴容實作

LinkList 是一個雙鏈表,在添加和洗掉元素時具有比 ArrayList 更好的性能.但在 get 與 set 方面弱于

ArrayList.當然,這些對比都是指資料量很大或者操作很頻繁，

7.HashMap 和 HashTable 的區別

（1）兩者父類不同

HashMap 是繼承自 AbstractMap 類，而 Hashtable 是繼承自 Dictionary 類，不過它們都實作了同時實作了 map、Cloneable（可復制）、Serializable（可序列化）這三個介面，

（2）對外提供的介面不同

Hashtable 比 HashMap 多提供了 elments() 和 contains() 兩個方法，

elments() 方法繼承自 Hashtable 的父類 Dictionnary，elements() 方法用于回傳此 Hashtable 中的 value 的列舉，

contains()方法判斷該 Hashtable 是否包含傳入的 value，它的作用與 containsValue()一致，事實上，contansValue() 就只是呼叫了一下 contains() 方法，

（3）對 null 的支持不同

Hashtable：key 和 value 都不能為 null，

HashMap：key 可以為 null，但是這樣的 key 只能有一個，因為必須保證 key 的唯一性；可以有多個 key 值對應的 value 為 null，

（4）安全性不同

HashMap 是執行緒不安全的，在多執行緒并發的環境下，可能會產生死鎖等問題，因此需要開發人員自己處理多執行緒的安全問題，

Hashtable 是執行緒安全的，它的每個方法上都有 synchronized 關鍵字，因此可直接用于多執行緒中，雖然 HashMap 是執行緒不安全的，但是它的效率遠遠高于 Hashtable，這樣設計是合理的，因為大部分的使用場景都是單執行緒，當需要多執行緒操作的時候可以使用執行緒安全的 ConcurrentHashMap，

ConcurrentHashMap 雖然也是執行緒安全的，但是它的效率比 Hashtable 要高好多倍，因為

ConcurrentHashMap 使用了分段鎖，并不對整個資料進行鎖定，

（5）計算 hash 值的方法不同

8.Collection 包結構，與 Collections 的區別

Collection 是集合類的上級介面，子介面有 Set、List、LinkedList、ArrayList、Vector、Stack、Set；Collections 是集合類的一個幫助類， 它包含有各種有關集合操作的靜態多型方法，用于實作對各種集合的搜索、排序、執行緒安全化等操作，此類不能實體化，就像一個工具類，服務于 Java 的 Collection 框架，

9.Java 的四種參考，強弱軟虛

強參考

強參考是平常中使用最多的參考，強參考在程式記憶體不足（OOM）的時候也不會被回收，使用方式：

String str = new String("str");

軟參考

軟參考在程式記憶體不足時，會被回收，使用方式：

// 注意：wrf 這個參考也是強參考，它是指向 SoftReference 這個物件的，
// 這里的軟參考指的是指向 new String("str")的參考，也就是 SoftReference 類中 T
SoftReference<String> wrf = new SoftReference<String>(new String("str"));

可用場景： 創建快取的時候，創建的物件放進快取中，當記憶體不足時，JVM 就會回收早先創建的物件，

弱參考

弱參考就是只要 JVM 垃圾回收器發現了它，就會將之回收，使用方式：

WeakReference<String> wrf = new WeakReference<String>(str);

可用場景： Java 原始碼中的 java.util.WeakHashMap 中的 key 就是使用弱參考，我的理解就是，一旦我不需要某個參考，JVM 會自動幫我處理它，這樣我就不需要做其它操作，

虛參考

虛參考的回識訓制跟弱參考差不多，但是它被回收之前，會被放入 ReferenceQueue 中，注意哦，其它參考是被 JVM 回收后才被傳入 ReferenceQueue 中的，由于這個機制，所以虛參考大多被用于參考銷毀前的處理作業，還有就是，虛參考創建的時候，必須帶有 ReferenceQueue，使用

例子：

PhantomReference<String> prf = new PhantomReference<String>(new
String("str"), new ReferenceQueue<>());

可用場景： 物件銷毀前的一些操作，比如順澩釋放等，** Object.finalize()雖然也可以做這類動作，但是這個方式即不安全又低效，

10.a=a+b 與 a+=b 有什么區別嗎?

運算子會進行隱式自動型別轉換,此處 a+=b 隱式的將加操作的結果型別強制轉換為持有結果的型別,

byte a = 127;
byte b = 127;
b = a + b;
// 報編譯錯誤:cannot convert from int to byte
b += a;

以下代碼是否有錯,有的話怎么改？

short s1= 1;
s1 = s1 + 1;

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

正確寫法：

short s1= 1;
s1 += 1;

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

11.try catch ?nally，try 里有 return，?nally 還執行么？

執行，并且?nally 的執行早于 try 里面的 return

結論：

（1）不管有木有出現例外，?nally 塊中代碼都會執行；

（2）當 try 和 catch 中有 return 時，?nally 仍然會執行；

（3）?nally 是在 return 后面的運算式運算后執行的（此時并沒有回傳運算后的值，而是先把要回傳的值保存起來，管?nally 中的代碼怎么樣，回傳的值都不會改變，任然是之前保存的值），所以函式回傳值是在?nally 執行前確定的；

（4）?nally 中最好不要包含 return，否則程式會提前退出，回傳值不是 try 或 catch 中保存的回傳值，、

12.Java 執行緒實作/創建方式

繼承 Thread 類

Thread 類本質上是實作了 Runnable 介面的一個實體，代表一個執行緒的實體，啟動執行緒的唯一方法就是通過 Thread 類的 start()實體方法，start()方法是一個 native 方法，它將啟動一個新執行緒，并執行 run()方法，

 public class MyThread extends Thread { 
         public void run() { 
             System.out.println("MyThread.run()"); 
         } 
    } 
        MyThread myThread1 = new MyThread(); 
        myThread1.start();

實作 Runnable 介面

如果自己的類已經 extends 另一個類，就無法直接 extends Thread，此時，可以實作一個Runnable 介面，

public class MyThread extends OtherClass implements Runnable { 
        public void run() { 
             System.out.println("MyThread.run()"); 
         } 
    } 
    //啟動 MyThread
    MyThread myThread = new MyThread(); 
    Thread thread = new Thread(myThread); 
    thread.start(); 
    target.run()
    public void run() { 
     if (target != null) { 
     target.run(); 
     } 
    }

13.執行緒池原理

執行緒池做的作業主要是控制運行的執行緒的數量，處理程序中將任務放入佇列，然后在執行緒創建后啟動這些任務，如果執行緒數量超過了最大數量超出數量的執行緒排隊等候，等其它執行緒執行完畢，再從佇列中取出任務來執行，主要特點為：執行緒復用；控制最大并發數；管理執行緒，

執行緒復用 一個 Thread 的類都有一個 start 方法， 當呼叫 start 啟動執行緒時 Java 虛擬機會呼叫該類的 run 方法， 那么該類的 run() 方法中就是呼叫了 Runnable 物件的 run() 方法， 我們可以繼承重寫 Thread 類，在其 start 方法中添加不斷回圈呼叫傳遞過來的 Runnable 物件， 這就是執行緒池的實作原理，回圈方法中不斷獲取 Runnable 是用 Queue 實作的，在獲取下一個 Runnable 之前可以是阻塞的，

執行緒池的組成 一般的執行緒池主要分為以下 4 個組成部分：

（1）執行緒池管理器：用于創建并管理執行緒池， （2）作業執行緒：執行緒池中的執行緒， （3）任務介面：每個任務必須實作的介面，用于作業執行緒調度其運行， （4）任務佇列：用于存放待處理的任務，提供一種緩沖機制，

Java 中的執行緒池是通過 Executor 框架實作的，該框架中用到了 Executor，Executors，ExecutorService，ThreadPoolExecutor ，Callable 和 Future、FutureTask 這幾個類，

ThreadPoolExecutor 的構造方法如下：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);

corePoolSize：指定了執行緒池中的執行緒數量，

maximumPoolSize：指定了執行緒池中的最大執行緒數量，

keepAliveTime：當前執行緒池數量超過 corePoolSize 時，多余的空閑執行緒的存活時間，即多次時間內會被銷毀，

unit：keepAliveTime 的單位，

workQueue：任務佇列，被提交但尚未被執行的任務，

threadFactory：執行緒工廠，用于創建執行緒，一般用默認的即可，

handler：拒絕策略，當任務太多來不及處理，如何拒絕任務，

拒絕策略 執行緒池中的執行緒已經用完了，無法繼續為新任務服務，同時，等待佇列也已經排滿了，再也塞不下新任務了，這時候我們就需要拒絕策略機制合理的處理這個問題，

JDK 內置的拒絕策略如下：

AbortPolicy ： 直接拋出例外，阻止系統正常運行，

CallerRunsPolicy ： 只要執行緒池未關閉，該策略直接在呼叫者執行緒中，運行當前被丟棄的任務，顯然這樣做不會真的丟棄任務，但是，任務提交執行緒的性能極有可能會急劇下降，

DiscardOldestPolicy ： 丟棄最老的一個請求，也就是即將被執行的一個任務，并嘗試再次提交當前任務，

DiscardPolicy ： 該策略默默地丟棄無法處理的任務，不予任何處理，如果允許任務丟失，這是最好的一種方案，

以上內置拒絕策略均實作了 RejectedExecutionHandler 介面，若以上策略仍無法滿足實際需要，完全可以自己擴展 RejectedExecutionHandler 介面，

Java 執行緒池作業程序 （1）執行緒池剛創建時，里面沒有一個執行緒，任務佇列是作為引數傳進來的，不過，就算佇列里面有任務，執行緒池也不會馬上執行它們，

（2）當呼叫 execute() 方法添加一個任務時，執行緒池會做如下判斷：

a) 如果正在運行的執行緒數量小于 corePoolSize，那么馬上創建執行緒運行這個任務； b) 如果正在運行的執行緒數量大于或等于 corePoolSize，那么將這個任務放入佇列； c) 如果這時候佇列滿了，而且正在運行的執行緒數量小maximumPoolSize，那么還是要創建非核心執行緒立刻運行這個任務； d) 如果佇列滿了，而且正在運行的執行緒數量大于或等maximumPoolSize，那么執行緒池會拋出例外 RejectExecutionException，

（3）當一個執行緒完成任務時，它會從佇列中取下一個任務來執行，

（4）當一個執行緒無事可做，超過一定的時間（keepAliveTime）時，執行緒池會判斷，如果當前運行的執行緒數大于 corePoolSize，那么這個執行緒就被停掉，所以執行緒池的所有任務完成后，它最侄訓收縮到 corePoolSize 的大小，

14.Java 常用演算法

1. 快速排序演算法
快速排序的原理：選擇一個關鍵值作為基準值，比基準值小的都在左邊序列（一般是無序的），比基準值大的都在右邊（一般是無序的），一般選擇序列的第一個元素，一次回圈：從后往前比較，用基準值和最后一個值比較，如果比基準值小的交換位置，如果沒有繼續比較下一個，直到找到第一個比基準值小的值才交換，找到這個值之后，又從前往后開始比較，如果有比基準值大的，交換位置，如果沒有繼續比較下一個，直到找到第一個比基準值大的值才交換，直到從前往后的比較索引>從后往前比較的索引，結束第一次回圈，此時，對于基準值來說，左右兩邊就是有序的了，

 public void sort(int[] a,int low,int high){
         int start = low;
         int end = high;
         int key = a[low]; 
         while(end>start){
         //從后往前比較
         while(end>start&&a[end]>=key) 
        //如果沒有比關鍵值小的，比較下一個，直到有比關鍵值小的交換位置，然后又從前往后比較
         end--;
         if(a[end]<=key){
             int temp = a[end];
             a[end] = a[start];
             a[start] = temp;
         }
         //從前往后比較
         while(end>start&&a[start]<=key)
        //如果沒有比關鍵值大的，比較下一個，直到有比關鍵值大的交換位置
         start++;
         if(a[start]>=key){
             int temp = a[start];
             a[start] = a[end];
             a[end] = temp;
         }
         //此時第一次回圈比較結束，關鍵值的位置已經確定了，左邊的值都比關鍵值小，右邊的值都比關鍵值大，但是兩邊的順序還有可能是不一樣的，進行下面的遞回呼叫
     }
         //遞回
        if(start>low) sort(a,low,start-1);//左邊序列，第一個索引位置到關鍵值索引-1
         if(end<high) sort(a,end+1,high);//右邊序列，從關鍵值索引+1 到最后一個
         }
 }

2 .冒泡排序演算法
（1）比較前后相鄰的二個資料，如果前面資料大于后面的資料，就將這二個資料交換，

（2）這樣對陣列的第 0 個資料到 N-1 個資料進行一次遍歷后，最大的一個資料就“沉”到陣列第N-1 個位置，

（3）N=N-1，如果 N 不為 0 就重復前面二步，否則排序完成，

public static void bubbleSort1(int [] a, int n){
         int i, j;
         for(i=0; i<n; i++){//表示 n 次排序程序，
             for(j=1; j<n-i; j++){
                 if(a[j-1] > a[j]){//前面的數字大于后面的數字就交換
                //交換 a[j-1]和 a[j]
                int temp;
                temp = a[j-1];
                a[j-1] = a[j];
                a[j]=temp;
                }
            }
         }
    }

15.Spring Beans

什么是Spring beans？

Spring beans 是那些形成Spring應用的主干的java物件，它們被Spring IOC容器初始化，裝配，和管理，這些beans通過容器中配置的元資料創建，比如，以XML檔案中 的形式定義，

一個 Spring Bean 定義 包含什么？

一個Spring Bean 的定義包含容器必知的所有配置元資料，包括如何創建一個bean，它的生命周期詳情及它的依賴，

如何給Spring 容器提供配置元資料？Spring有幾種配置方式

這里有三種重要的方法給Spring 容器提供配置元資料，

XML組態檔，
基于注解的配置，
基于java的配置，

Spring組態檔包含了哪些資訊

Spring組態檔是個XML 檔案，這個檔案包含了類資訊，描述了如何配置它們，以及如何相互呼叫，

Spring基于xml注入bean的幾種方式

Set方法注入；
構造器注入：①通過index設定引數的位置；②通過type設定引數型別；
靜態工廠注入；
實體工廠；

總結：

互聯網大廠比較喜歡的人才特點：對技術有熱情，強硬的技識訓礎實力；主動，善于團隊協作，善于總結思考，無論是哪家公司，都很重視高并發高可用技術，重視基礎，所以千萬別小看任何知識，面試是一個雙向選擇的程序，不要抱著畏懼的心態去面試，不利于自己的發揮，同時看中的應該不止薪資，還要看你是不是真的喜歡這家公司，是不是能真的得到鍛煉，其實我寫了這么多，只是我自己的總結，并不一定適用于所有人，相信經過一些面試，大家都會有這些感觸，

另外想要面試答案的小伙伴請點擊795983544 暗號CSDN自行領取，本人還整理收藏了20年多家公司面試知識點以及各種技術點整理 下面有部分截圖希望能對大家有所幫助，