[題庫]Java 面試知識點

14）交換變量的三種方式

答：

• 第一種：通過第三個變量

public class Test{

public static void main(String[] args) {

int x = 5;

int y = 10;

swap(x,y);

System.out.println(x);

System.out.println(y);

Value v = new Value(5,10);

swap(v);

System.out.println(v.x);

System.out.println(v.y);

}

// 無效的交換：形參的改變無法反作用於實參

public static void swap(int x,int y) {

int temp = x;

x = y;

y = temp;

}

// 有效的交換：通過引用（變量指向一個對象）來修改成員變量

public static void swap(Value value) {

int temp = value.x;

value.x = value.y;

value.y = temp;

}

}

class Value{

int x;

int y;

public Value(int x,int y) {

this.x = x;

this.y = y;

}

}

輸出的結果：

5

10

10

5

這有點類似於C/C++語言中的指針，不過相對來說更加安全。

事實上，其實如果把基礎類型int改成對應的包裝類的話其實可以更加簡單的完成這個操作，不過需要付出更多的內存代價。

第二種：通過通過相加的方式（相同的 Value 類不再重複展示）

public class Test{

public static void main(String[] args) {

Value v1 = new Value(5,10);

swap(v1);

System.out.println("v1交換之後的結果為：");

System.out.println(v1.x);

System.out.println(v1.y);

}

public static void swap(Value v) {

v.x = v.x + v.y;

v.y = v.x - v.y;

v.x = v.x - v.y;

}

}

輸出的結果：

v1的交換結果：

10

5

核心的算法就是swap方法:

v.x = v.x + v.y; // 把v.x與v.y的和存儲在v.x中

v.y = v.x - v.y; // v.x減掉v.y本來的值即為v.x

v.x = v.x - v.y; // v.x減掉v.y的值也就是以前x.y的值

這樣就可以不通過臨時變量，來達到交換兩個變量的目的，如果覺得上面的方法不太容易理解，我們也可以用另一個參數z來表示上述過程：

int z = v.x + v.y; // 把v.x與v.y的和存儲在z中

v.y = z - v.y; // z減掉以前的v.y就等於v.x

v.x = z - v.y; // z減掉現在的v.y即以前的v.x，即為v.y

但並不推薦這種做法，原因在於當數值很大的時候，16進制的求和運算可能造成數據的溢出，雖然最後的結果依然會是我們所期望的那樣，但仍然不是十分可取。

• 第三種：通過異或的方式：

位異或運算符（^）有這樣的一個性質，就是兩個整型的數據x與y，有：

（x ^ y ^ y） == x這說明，如果一個變量x異或另外一個變量y兩次，結果為x。通過這一點，可以實現交換兩個變量的值：

public class Test{

public static void main(String[] args) {

Value v1 = new Value(5,10);

swap(v1);

System.out.println("v1交換之後的結果為：");

System.out.println(v1.x);

System.out.println(v1.y);

}

public static void swap(Value v) {

v.x = v.x ^ v.y;

v.y = v.x ^ v.y;

v.x = v.x ^ v.y;

}

}

輸出的結果：

v1交換之後的結果為：

10

5

跟上面相加的方式過程幾乎類似，只不過運算的方式不同而已。異或的方法比相加更加可取的地方在於，異或不存在數據溢出。

15）Java 對象初始化順序？

答：不考慮靜態成員的初始化，調用一個對象的構造函數時，程序先調用父類的構造函數（可以通過super關鍵字指定父類的構造函數，否則默認調用無參的構造函數，並且需要在子類的構造函數的第一行調用），之後靜態成員變量的初始化函數和靜態初始化塊則按照在代碼當中的順序執行，成員變量如果沒有指定值的話則賦予默認值，即基本數據類型為0或false等，對象則為null；最後調用自身構造函數。

• 我們可以寫一段程序來對初始化順序進行一個簡單的驗證：

public class Derive extends Base

{

private Member m1 = new Member("Member 1");

{

System.out.println("Initial Block()");

}

public Derive() {

System.out.println("Derive()");

}

private Member m2 = new Member("Member 2");

private int i = getInt();

private int getInt()

{

System.out.println("getInt()");

return 2;

}

public static void main(String[] args)

{

new Derive();

}

}

class Base

{

public Base()

{

System.out.println("Base()");

}

}

class Member

{

public Member(String m)

{

System.out.println("Member() "+m);

}

}

程序的輸出結果是：

Base()

Member() Member 1

Initial Block()

Member() Member 2

getInt()

Derive()

16）true、false 與 null 是關鍵字嗎？

答：不是。true、false 是布爾類型的字面常量，null 是引用類型的字面常量。

面試官：那 goto 與 const 呢？

答：是。goto 與 const 均是 Java 語言保留的關鍵字，即沒有任何語法應用。

17）exception 和 error 有什麼區別？

答：exception 和 error都是 Throwable 的子類。exception 用於用戶程序可以捕獲的異常情況；error 定義了不期望被用戶程序捕獲的異常。

exception 表示一種設計或設計的問題，也就是說只要程序正常運行，從不會發生的情況；而 error 表示回覆不是不可能但是很困難的情況下的一種嚴重問題，比如內存溢出，不可能指望程序處理這樣的情況。

18）throw 和 throws 有什麼區別？

答：throw 關鍵字用來在程序中明確的拋出異常，相反，throws 語句用來表明方法不能處理的異常。每一個方法都必須要指定哪些異常不能處理，所以方法的調用者才能夠確保處理可能發生的異常，多個異常是用逗號分隔的。

小結：本節主要闡述了 Java 基礎知識，並沒有涉及到一些高級的特性，這些問題一般難度不大，適當複習下，應該沒問題。

（二）Java 中常見集合

集合這方面的考察相當多，這部分是面試中必考的知識點。

1）說說常見的集合有哪些吧？

答：Map接口和Collection接口是所有集合框架的父接口：

1. Collection接口的子接口包括：Set接口和List接口
2. Map接口的實現類主要有：HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等
3. Set接口的實現類主要有：HashSet、TreeSet、LinkedHashSet等
4. List接口的實現類主要有：ArrayList、LinkedList、Stack以及Vector等

2）HashMap和Hashtable的區別有哪些？（必問）

答：

1. HashMap沒有考慮同步，是線程不安全的；Hashtable使用了synchronized關鍵字，是線程安全的；
2. 前者允許null作為Key；後者不允許null作為Key

3）HashMap的底層實現你知道嗎？

答：在Java8之前，其底層實現是數組+鏈表實現，Java8使用了數組+鏈表+紅黑樹實現。此時你可以簡單的在紙上畫圖分析：

4）ConcurrentHashMap 和 Hashtable 的區別？（必問）

答：ConcurrentHashMap 結合了 HashMap 和 HashTable 二者的優勢。HashMap 沒有考慮同步，HashTable 考慮了同步的問題。但是 HashTable 在每次同步執行時都要鎖住整個結構。ConcurrentHashMap 鎖的方式是稍微細粒度的。ConcurrentHashMap 將 hash 表分為 16 個桶（默認值），諸如get,put,remove 等常用操作只鎖當前需要用到的桶。

面試官：ConcurrentHashMap的具體實現知道嗎？

答：

1. 該類包含兩個靜態內部類 HashEntry 和 Segment ；前者用來封裝映射表的鍵值對，後者用來充當鎖的角色；

2. Segment 是一種可重入的鎖 ReentrantLock，每個 Segment 守護一個HashEntry 數組裡得元素，當對 HashEntry 數組的數據進行修改時，必須首先獲得對應的 Segment 鎖。

5）HashMap 的長度為什麼是2的冪次方？

答：

1. 通過將 Key 的 hash 值與 length - 1 進行 & 運算，實現了當前 Key 的定位，2 的冪次方可以減少衝突（碰撞）的次數，提高 HashMap 查詢效率

2. 如果 length 為 2 的次冪 則 length-1 轉化為二進制必定是 11111……的形式，在於 h 的二進制與操作效率會非常的快，而且空間不浪費；如果 length 不是 2 的次冪，比如 length 為 15，則 length - 1 為 14，對應的二進制為 1110，在於 h 與操作，最後一位都為 0 ，而 0001，0011，0101，1001，1011，0111，1101 這幾個位置永遠都不能存放元素了，空間浪費相當大，更糟的是這種情況中，數組可以使用的位置比數組長度小了很多，這意味著進一步增加了碰撞的幾率，減慢了查詢的效率！這樣就會造成空間的浪費。

6）List和Set的區別是啥？

答：List元素是有序的，可以重複；Set元素是無序的，不可以重複。

7）List、Set和Map的初始容量和加載因子：

答：

1. List

• ArrayList的初始容量是10；加載因子為0.5；擴容增量：原容量的 0.5倍+1；一次擴容後長度為15。
• Vector初始容量為10，加載因子是1。擴容增量：原容量的 1倍，如 Vector的容量為10，一次擴容後是容量為20。

2. Set

HashSet，初始容量為16，加載因子為0.75；擴容增量：原容量的 1 倍；如 HashSet的容量為16，一次擴容後容量為32

3. Map

HashMap，初始容量16，加載因子為0.75；擴容增量：原容量的 1 倍；如 HashMap的容量為16，一次擴容後容量為32

8）Comparable接口和Comparator接口有什麼區別？

答：

1. 前者簡單，但是如果需要重新定義比較類型時，需要修改源代碼。

2. 後者不需要修改源代碼，自定義一個比較器，實現自定義的比較方法。具體解析參考博客：Java集合框架—Set

9）Java集合的快速失敗機制 “fail-fast”

答：

是java集合的一種錯誤檢測機制，當多個線程對集合進行結構上的改變的操作時，有可能會產生 fail-fast 機制。

例如：假設存在兩個線程（線程1、線程2），線程1通過Iterator在遍歷集合A中的元素，在某個時候線程2修改了集合A的結構（是結構上面的修改，而不是簡單的修改集合元素的內容），那麼這個時候程序就會拋出 ConcurrentModificationException 異常，從而產生fail-fast機制。

原因：迭代器在遍歷時直接訪問集合中的內容，並且在遍歷過程中使用一個 modCount 變量。集合在被遍歷期間如果內容發生變化，就會改變modCount的值。每當迭代器使用hashNext()/next()遍歷下一個元素之前，都會檢測modCount變量是否為expectedmodCount值，是的話就返回遍歷；否則拋出異常，終止遍歷。

解決辦法：

1. 在遍歷過程中，所有涉及到改變modCount值得地方全部加上synchronized。

2. 使用CopyOnWriteArrayList來替換ArrayList

10）ArrayList 和 Vector 的區別

答：

這兩個類都實現了 List 接口（List 接口繼承了 Collection 接口），他們都是有序集合，即存儲在這兩個集合中的元素位置都是有順序的，相當於一種動態的數組，我們以後可以按位置索引來取出某個元素，並且其中的數據是允許重複的，這是與 HashSet 之類的集合的最大不同處，HashSet 之類的集合不可以按索引號去檢索其中的元素，也不允許有重複的元素。

ArrayList 與 Vector 的區別主要包括兩個方面：

1. 同步性：
2. Vector 是線程安全的，也就是說它的方法之間是線程同步（加了synchronized 關鍵字）的，而 ArrayList 是線程不安全的，它的方法之間是線程不同步的。如果只有一個線程會訪問到集合，那最好是使用 ArrayList，因為它不考慮線程安全的問題，所以效率會高一些；如果有多個線程會訪問到集合，那最好是使用 Vector，因為不需要我們自己再去考慮和編寫線程安全的代碼。
3. 數據增長：
4. ArrayList 與 Vector 都有一個初始的容量大小，當存儲進它們裡面的元素的個人超過了容量時，就需要增加 ArrayList 和 Vector 的存儲空間，每次要增加存儲空間時，不是隻增加一個存儲單元，而是增加多個存儲單元，每次增加的存儲單元的個數在內存空間利用與程序效率之間要去的一定的平衡。Vector 在數據滿時（加載因子1）增長為原來的兩倍（擴容增量：原容量的 1 倍），而 ArrayList 在數據量達到容量的一半時（加載因子 0.5）增長為原容量的 0.5 倍 + 1 個空間。

面試官：那 ArrayList 和 LinkedList 的區別呢？

答：

1. LinkedList 實現了 List 和 Deque 接口，一般稱為雙向鏈表；
2. LinkedList 在插入和刪除數據時效率更高，ArrayList 在查找某個 index 的數據時效率更高；
3. LinkedList 比 ArrayList 需要更多的內存；

面試官：Array 和 ArrayList 有什麼區別？什麼時候該應 Array 而不是 ArrayList 呢？

答：它們的區別是：

1. Array 可以包含基本類型和對象類型，ArrayList 只能包含對象類型。
2. Array 大小是固定的，ArrayList 的大小是動態變化的。
3. ArrayList 提供了更多的方法和特性，比如：addAll()，removeAll()，iterator() 等等。

對於基本類型數據，集合使用自動裝箱來減少編碼工作量。但是，當處理固定大小的基本數據類型的時候，這種方式相對比較慢。

11）如何去掉一個 Vector 集合中重複的元素？

答：

Vector newVector = new Vector();

for (int i = 0; i < vector.size(); i++) {

Object obj = vector.get(i);

if (!newVector.contains(obj)) {

newVector.add(obj);

}

}

還有一種簡單的方式，利用了 Set 不允許重複元素的特性：

HashSet set = new HashSet(vector);

小結：本小節是 Java 中關於集合的考察，是 Java 崗位面試中必考的知識點，除了應該掌握以上的問題，包括各個集合的底層實現也建議各位同學閱讀，加深理解。

12）如何權衡是使用無序的數組還是有序的數組？

答：有序數組最大的好處在於查找的時間複雜度是O(log n)，而無序數組是O(n)。有序數組的缺點是插入操作的時間複雜度是O(n)，因為值大的元素需要往後移動來給新元素騰位置。相反，無序數組的插入時間複雜度是常量O(1)。

---

分享到:

---

閱讀更多 壹號職 的文章

關鍵字: 軟件 知識點 題庫

---