當前位置：首頁 > 编程语言 > java >内容正文

java

java 多态判断非空_收藏Java 面试题全梳理

發布時間：2023/12/10 java 30 豆豆

生活随笔收集整理的這篇文章主要介紹了 java 多态判断非空_收藏Java 面试题全梳理小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

? 腳本之家

你與百萬開發者在一起

來源 | Java建設者(ID：javajianshe)

作者 |cxuan

如若轉載請聯系原公眾號

Java 基礎篇

Java 有哪些特點

并發性的：你可以在其中執行許多語句，而不必一次執行它
面向對象的：基于類和面向對象的編程語言。
獨立性的：支持一次編寫，到處運行的獨立編程語言，即編譯后的代碼可以在支持 Java 的所有平臺上運行。

Java 的特性

Java 的特性有如下這幾點

簡單，Java 會讓你的工作變得更加輕松，使你把關注點放在主要業務邏輯上，而不必關心指針、運算符重載、內存回收等與主要業務無關的功能。
便攜性，Java 是平臺無關性的，這意味著在一個平臺上編寫的任何應用程序都可以輕松移植到另一個平臺上。
安全性，編譯后會將所有的代碼轉換為字節碼，人類無法讀取。它使開發無病毒，無篡改的系統/應用成為可能。
動態性，它具有適應不斷變化的環境的能力，它能夠支持動態內存分配，從而減少了內存浪費，提高了應用程序的性能。
分布式，Java 提供的功能有助于創建分布式應用。使用遠程方法調用(RMI)，程序可以通過網絡調用另一個程序的方法并獲取輸出。您可以通過從互聯網上的任何計算機上調用方法來訪問文件。這是革命性的一個特點，對于當今的互聯網來說太重要了。
健壯性，Java 有強大的內存管理功能，在編譯和運行時檢查代碼，它有助于消除錯誤。
高性能，Java 最黑的科技就是字節碼編程，Java 代碼編譯成的字節碼可以輕松轉換為本地機器代碼。通過 JIT 即時編譯器來實現高性能。
解釋性，Java 被編譯成字節碼，由 Java 運行時環境解釋。
多線程性，Java支持多個執行線程(也稱為輕量級進程)，包括一組同步原語。這使得使用線程編程更加容易，Java 通過管程模型來實現線程安全性。

描述一下值傳遞和引用傳遞的區別

要想真正理解的話，可以參考這篇文章：https://www.zhihu.com/question/31203609

簡單理解的話就是

值傳遞是指在調用函數時將實際參數復制一份到函數中，這樣的話如果函數對其傳遞過來的形式參數進行修改，將不會影響到實際參數

引用傳遞是指在調用函數時將對象的地址直接傳遞到函數中，如果在對形式參數進行修改，將影響到實際參數的值。

== 和 equals 區別是什么

==是 Java 中一種操作符，它有兩種比較方式

對于基本數據類型來說， == 判斷的是兩邊的值是否相等

public?class?DoubleCompareAndEquals?{

????Person?person1?=?new?Person(24,"boy");
????Person?person2?=?new?Person(24,"girl");
????int?c?=?10;

????private?void?doubleCompare(){

????????int?a?=?10;
????????int?b?=?10;

????????System.out.println(a?==?b);
????????System.out.println(a?==?c);
????????System.out.println(person1.getId()?==?person2.getId());

????}
}

對于引用類型來說， == 判斷的是兩邊的引用是否相等，也就是判斷兩個對象是否指向了同一塊內存區域。

private?void?equals(){

??System.out.println(person1.getName().equals(person2.getName()));
}

equals是 Java 中所有對象的父類，即Object類定義的一個方法。它只能比較對象，它表示的是引用雙方的值是否相等。所以記住，并不是說 == 比較的就是引用是否相等，equals 比較的就是值，這需要區分來說的。

equals 用作對象之間的比較具有如下特性

自反性：對于任何非空引用 x 來說，x.equals(x) 應該返回 true。
對稱性：對于任何非空引用 x 和 y 來說，若x.equals(y)為 true，則y.equals(x)也為 true。
傳遞性：對于任何非空引用的值來說，有三個值，x、y 和 z，如果x.equals(y) 返回true，y.equals(z) 返回true，那么x.equals(z) 也應該返回true。
一致性：對于任何非空引用 x 和 y 來說，如果 x.equals(y) 相等的話，那么它們必須始終相等。
非空性：對于任何非空引用的值 x 來說，x.equals(null) 必須返回 false。

String 中的 equals 是如何重寫的

String 代表的是 Java 中的字符串，String 類比較特殊，它整個類都是被final修飾的，也就是說，String 不能被任何類繼承，任何修改String 字符串的方法都是創建了一個新的字符串。

equals 方法是 Object 類定義的方法，Object 是所有類的父類，當然也包括 String，String 重寫了equals方法，下面我們來看看是怎么重寫的

首先會判斷要比較的兩個字符串它們的引用是否相等。如果引用相等的話，直接返回 true ，不相等的話繼續下面的判斷
然后再判斷被比較的對象是否是 String 的實例，如果不是的話直接返回 false，如果是的話，再比較兩個字符串的長度是否相等，如果長度不想等的話也就沒有比較的必要了；長度如果相同，會比較字符串中的每個字符是否相等，一旦有一個字符不相等，就會直接返回 false。

下面是它的流程圖

這里再提示一下，你可能有疑惑什么時候是

if?(this?==?anObject)?{
??return?true;
}

這個判斷語句如何才能返回 true？因為都是字符串啊，字符串比較的不都是堆空間嗎，猛然一看發現好像永遠也不會走，但是你忘記了String.intern()方法，它表示的概念在不同的 JDK 版本有不同的區分

在 JDK1.7 及以后調用 intern 方法是判斷運行時常量池中是否有指定的字符串，如果沒有的話，就把字符串添加到常量池中，并返回常量池中的對象。

驗證過程如下

private?void?StringOverrideEquals(){

??String?s1?=?"aaa";
??String?s2?=?"aa"?+?new?String("a");
??String?s3?=?new?String("aaa");

??System.out.println(s1.intern().equals(s1));
??System.out.println(s1.intern().equals(s2));
??System.out.println(s3.intern().equals(s1));

}

首先 s1.intern.equals(s1) 這個無論如何都返回 true，因為 s1 字符串創建出來就已經在常量池中存在了。
然后第二條語句返回 false，因為 s1 返回的是常量池中的對象，而 s2 返回的是堆中的對象
第三條語句 s3.intern.equals(s1)，返回 true ，因為 s3 對象雖然在堆中創建了一個對象，但是 s3 中的 "aaa" 返回的是常量池中的對象。

為什么重寫 equals 方法必須重寫 hashcode 方法

equals 方法和 hashCode 都是 Object 中定義的方法，它們經常被一起重寫。

equals 方法是用來比較對象大小是否相等的方法，hashcode 方法是用來判斷每個對象 hash 值的一種方法。如果只重寫 equals 方法而不重寫 hashcode 方法，很可能會造成兩個不同的對象，它們的 hashcode 也相等，造成沖突。比如

String?str1?=?"通話";
String?str2?=?"重地";

它們兩個的 hashcode 相等，但是 equals 可不相等。

我們來看一下 hashCode 官方的定義

總結起來就是

如果在 Java 運行期間對同一個對象調用 hashCode 方法后，無論調用多少次，都應該返回相同的 hashCode，但是在不同的 Java 程序中，執行 hashCode 方法返回的值可能不一致。
如果兩個對象的 equals 相等，那么 hashCode 必須相同
如果兩個對象 equals 不相等，那么 hashCode 也有可能相同，所以需要重寫 hashCode 方法，因為你不知道 hashCode 的底層構造(反正我是不知道，有大牛可以傳授傳授)，所以你需要重寫 hashCode 方法，來為不同的對象生成不同的 hashCode 值，這樣能夠提高不同對象的訪問速度。
hashCode 通常是將地址轉換為整數來實現的。

String s1 = new String("abc") 在內存中創建了幾個對象

一個或者兩個，String s1 是聲明了一個 String 類型的 s1 變量，它不是對象。使用new關鍵字會在堆中創建一個對象，另外一個對象是abc，它會在常量池中創建，所以一共創建了兩個對象；如果 abc 在常量池中已經存在的話，那么就會創建一個對象。

詳細請翻閱筆者的另外一篇文章一篇與眾不同的 String、StringBuffer、StringBuilder 詳解

String 為什么是不可變的、jdk 源碼中的 String 如何定義的、為什么這么設計。

首先了解一下什么是不可變對象，不可變對象就是一經創建后，其對象的內部狀態不能被修改，啥意思呢？也就是說不可變對象需要遵守下面幾條原則

不可變對象的內部屬性都是 final 的
不可變對象的內部屬性都是 private 的
不可變對象不能提供任何可以修改內部狀態的方法、setter 方法也不行
不可變對象不能被繼承和擴展

與其說問 String 為什么是不可變的，不如說如何把 String 設計成不可變的。

String 類是一種對象，它是獨立于 Java 基本數據類型而存在的，String 你可以把它理解為字符串的集合，String 被設計為 final 的，表示 String 對象一經創建后，它的值就不能再被修改，任何對 String 值進行修改的方法就是重新創建一個字符串。String 對象創建后會存在于運行時常量池中，運行時常量池是屬于方法區的一部分，JDK1.7 后把它移到了堆中。

不可變對象不是真的不可變，可以通過反射來對其內部的屬性和值進行修改，不過一般我們不這樣做。

static 關鍵字是干什么用的？談談你的理解

static 是 Java 中非常重要的關鍵字，static 表示的概念是靜態的，在 Java 中，static 主要用來

修飾變量，static 修飾的變量稱為靜態變量、也稱為類變量，類變量屬于類所有，對于不同的類來說，static 變量只有一份，static 修飾的變量位于方法區中；static 修飾的變量能夠直接通過類名.變量名來進行訪問，不用通過實例化類再進行使用。
修飾方法，static 修飾的方法被稱為靜態方法，靜態方法能夠直接通過類名.方法名來使用，在靜態方法內部不能使用非靜態屬性和方法
static 可以修飾代碼塊，主要分為兩種，一種直接定義在類中，使用static{}，這種被稱為靜態代碼塊，一種是在類中定義靜態內部類，使用static class xxx來進行定義。
static 可以用于靜態導包，通過使用import static xxx?來實現，這種方式一般不推薦使用
static 可以和單例模式一起使用，通過雙重檢查鎖來實現線程安全的單例模式。

詳情請參考這篇文章一篇 static 還能難得住我？

final 關鍵字是干什么用的？談談你的理解

final 是 Java 中的關鍵字，它表示的意思是不可變的，在 Java 中，final 主要用來

修飾類，final 修飾的類不能被繼承，不能被繼承的意思就是不能使用extends來繼承被 final 修飾的類。
修飾變量，final 修飾的變量不能被改寫，不能被改寫的意思有兩種，對于基本數據類型來說，final 修飾的變量，其值不能被改變，final 修飾的對象，對象的引用不能被改變，但是對象內部的屬性可以被修改。final 修飾的變量在某種程度上起到了不可變的效果，所以，可以用來保護只讀數據，尤其是在并發編程中，因為明確的不能再為 final 變量進行賦值，有利于減少額外的同步開銷。
修飾方法，final 修飾的方法不能被重寫。
final 修飾符和 Java 程序性能優化沒有必然聯系

抽象類和接口的區別是什么

抽象類和接口都是 Java 中的關鍵字，抽象類和接口中都允許進行方法的定義，而不用具體的方法實現。抽象類和接口都允許被繼承，它們廣泛的應用于 JDK 和框架的源碼中，來實現多態和不同的設計模式。

不同點在于

抽象級別不同：類、抽象類、接口其實是三種不同的抽象級別，抽象程度依次是接口 > 抽象類 > 類。在接口中，只允許進行方法的定義，不允許有方法的實現，抽象類中可以進行方法的定義和實現；而類中只允許進行方法的實現，我說的方法的定義是不允許在方法后面出現{}
使用的關鍵字不同：類使用class來表示；抽象類使用abstract class來表示；接口使用interface來表示
變量：接口中定義的變量只能是公共的靜態常量，抽象類中的變量是普通變量。

重寫和重載的區別

在 Java 中，重寫和重載都是對同一方法的不同表現形式，下面我們針對重寫和重載做一下簡單的區分

子父級關系不同，重寫是針對子級和父級的不同表現形式，而重載是在同一類中的不同表現形式；
概念不同，子類重寫父類的方法一般使用@override來表示；重寫后的方法其方法的聲明和參數類型、順序必須要與父類完全一致；重載是針對同一類中概念，它要求重載的方法必須滿足下面任何一個要求：方法參數的順序，參數的個數，參數的類型任意一個保持不同即可。

byte的取值范圍是多少，怎么計算出來的

byte 的取值范圍是 -128 -> 127 之間，一共是 256 。一個 byte 類型在計算機中占據一個字節，那么就是 8 bit，所以最大就是 2^7 = 1111 1111。

Java 中用補碼來表示二進制數，補碼的最高位是符號位，最高位用 0 表示正數，最高位 1 表示負數，正數的補碼就是其本身，由于最高位是符號位，所以正數表示的就是 0111 1111 ，也就是 127。最大負數就是 1111 1111，這其中會涉及到兩個 0 ，一個 +0 ，一個 -0 ，+0 歸為正數，也就是 0 ，-0 歸為負數，也就是 -128，所以 byte 的范圍就是 -128 - 127。

HashMap 和 HashTable 的區別

相同點

HashMap 和 HashTable 都是基于哈希表實現的，其內部每個元素都是key-value鍵值對，HashMap 和 HashTable 都實現了 Map、Cloneable、Serializable 接口。

不同點

父類不同：HashMap 繼承了AbstractMap類，而 HashTable 繼承了Dictionary類

空值不同：HashMap 允許空的 key 和 value 值，HashTable 不允許空的 key 和 value 值。HashMap 會把 Null key 當做普通的 key 對待。不允許 null key 重復。

線程安全性：HashMap 不是線程安全的，如果多個外部操作同時修改 HashMap 的數據結構比如 add 或者是 delete，必須進行同步操作，僅僅對 key 或者 value 的修改不是改變數據結構的操作。可以選擇構造線程安全的 Map 比如Collections.synchronizedMap或者是ConcurrentHashMap。而 HashTable 本身就是線程安全的容器。
性能方面：雖然 HashMap 和 HashTable 都是基于單鏈表的，但是 HashMap 進行 put 或者 get? 操作，可以達到常數時間的性能；而 HashTable 的 put 和 get 操作都是加了synchronized鎖的，所以效率很差。

初始容量不同：HashTable 的初始長度是11，之后每次擴充容量變為之前的 2n+1(n為上一次的長度)而 HashMap 的初始長度為16，之后每次擴充變為原來的兩倍。創建時，如果給定了容量初始值，那么HashTable 會直接使用你給定的大小，而 HashMap 會將其擴充為2的冪次方大小。

HashMap 和 HashSet 的區別

HashSet 繼承于 AbstractSet 接口，實現了 Set、Cloneable,、java.io.Serializable 接口。HashSet 不允許集合中出現重復的值。HashSet 底層其實就是 HashMap，所有對 HashSet 的操作其實就是對 HashMap 的操作。所以 HashSet 也不保證集合的順序，也不是線程安全的容器。

HashMap 的底層結構

JDK1.7 中，HashMap 采用位桶 + 鏈表的實現，即使用鏈表來處理沖突，同一 hash 值的鏈表都存儲在一個數組中。但是當位于一個桶中的元素較多，即 hash 值相等的元素較多時，通過 key 值依次查找的效率較低。

所以，與 JDK 1.7 相比，JDK 1.8 在底層結構方面做了一些改變，當每個桶中元素大于 8 的時候，會轉變為紅黑樹，目的就是優化查詢效率。

HashMap 的長度為什么是 2 的冪次方

這道題我想了幾天，之前和群里小伙伴們探討每日一題的時候，問他們為什么 length%hash == (n - 1) & hash，它們說相等的前提是 length 的長度 2 的冪次方，然后我回了一句難道 length 還能不是 2 的冪次方嗎？其實是我沒有搞懂因果關系，因為 HashMap 的長度是 2 的冪次方，所以使用余數來判斷在桶中的下標。如果 length 的長度不是 2 的冪次方，小伙伴們可以舉個例子來試試

例如長度為 9 時候，3 & (9-1) = 0，2 & (9-1) = 0 ，都在 0 上，碰撞了；

這樣會增大 HashMap 碰撞的幾率。

HashMap 多線程操作導致死循環問題

HashMap 不是一個線程安全的容器，在高并發場景下，應該使用ConcurrentHashMap，在多線程場景下使用 HashMap 會造成死循環問題(基于 JDK1.7)，出現問題的位置在rehash處，也就是

do?{
????Entry?next?=?e.next;?//?int?i?=?indexFor(e.hash,?newCapacity);
????e.next?=?newTable[i];
????newTable[i]?=?e;
????e?=?next;
}?while?(e?!=?null);

這是 JDK1.7 的 rehash 代碼片段，在并發的場景下會形成環。

JDK1.8 也會造成死循環問題。

HashMap 線程安全的實現有哪些

因為 HashMap 不是一個線程安全的容器，所以并發場景下推薦使用ConcurrentHashMap，或者使用線程安全的 HashMap，使用Collections包下的線程安全的容器，比如說

Collections.synchronizedMap(new?HashMap());

還可以使用 HashTable ，它也是線程安全的容器，基于 key-value 存儲，經常用 HashMap 和 HashTable 做比較就是因為 HashTable 的數據結構和 HashMap 相同。

上面效率最高的就是 ConcurrentHashMap。

講一下 HashMap put 的過程

首先會使用 hash 函數來計算 key，然后執行真正的插入方法

final?V?putVal(int?hash,?K?key,?V?value,?boolean?onlyIfAbsent,boolean?evict)?{
??Node[]?tab;?Node?p;?int?n,?i;//?如果table?為null?或者沒有為table分配內存，就resize一次if?((tab?=?table)?==?null?||?(n?=?tab.length)?==?0)
????n?=?(tab?=?resize()).length;//?指定hash值節點為空則直接插入，這個(n?-?1)?&?hash才是表中真正的哈希if?((p?=?tab[i?=?(n?-?1)?&?hash])?==?null)
????tab[i]?=?newNode(hash,?key,?value,?null);//?如果不為空else?{
????Node?e;?K?k;//?計算表中的這個真正的哈希值與要插入的key.hash相比if?(p.hash?==?hash?&&
????????((k?=?p.key)?==?key?||?(key?!=?null?&&?key.equals(k))))
??????e?=?p;//?若不同的話，并且當前節點已經在?TreeNode?上了else?if?(p?instanceof?TreeNode)//?采用紅黑樹存儲方式
??????e?=?((TreeNode)p).putTreeVal(this,?tab,?hash,?key,?value);//?key.hash?不同并且也不再?TreeNode?上，在鏈表上找到?p.next==nullelse?{for?(int?binCount?=?0;?;?++binCount)?{if?((e?=?p.next)?==?null)?{//?在表尾插入
??????????p.next?=?newNode(hash,?key,?value,?null);//?新增節點后如果節點個數到達閾值，則進入?treeifyBin()?進行再次判斷if?(binCount?>=?TREEIFY_THRESHOLD?-?1)?//?-1?for?1st
????????????treeifyBin(tab,?hash);break;
????????}//?如果找到了同hash、key的節點，那么直接退出循環if?(e.hash?==?hash?&&
????????????((k?=?e.key)?==?key?||?(key?!=?null?&&?key.equals(k))))break;//?更新?p?指向下一節點
????????p?=?e;
??????}
????}//?map中含有舊值，返回舊值if?(e?!=?null)?{?//?existing?mapping?for?key
??????V?oldValue?=?e.value;if?(!onlyIfAbsent?||?oldValue?==?null)
????????e.value?=?value;
??????afterNodeAccess(e);return?oldValue;
????}
??}//?map調整次數?+?1
??++modCount;//?鍵值對的數量達到閾值，需要擴容if?(++size?>?threshold)
????resize();
??afterNodeInsertion(evict);return?null;
}

HashMap put 方法的核心就是在putval方法，它的插入過程如下

首先會判斷 HashMap 中是否是新構建的，如果是的話會首先進行 resize
然后判斷需要插入的元素在 HashMap 中是否已經存在(說明出現了碰撞情況)，如果不存在，直接生成新的k-v 節點存放，再判斷是否需要擴容。
如果要插入的元素已經存在的話，說明發生了沖突，這就會轉換成鏈表或者紅黑樹來解決沖突，首先判斷鏈表中的 hash，key 是否相等，如果相等的話，就用新值替換舊值，如果節點是屬于 TreeNode 類型，會直接在紅黑樹中進行處理，如果 hash ,key 不相等也不屬于 TreeNode 類型，會直接轉換為鏈表處理，進行鏈表遍歷，如果鏈表的 next 節點是 null，判斷是否轉換為紅黑樹，如果不轉換的話，在遍歷過程中找到 key 完全相等的節點，則用新節點替換老節點

ConcurrentHashMap 底層實現

ConcurrentHashMap 是線程安全的 Map，它也是高并發場景下的首選數據結構，ConcurrentHashMap 底層是使用分段鎖來實現的。

Integer 緩存池

Integer 緩存池也就是IntegerCache，它是 Integer 的靜態內部類。

它的默認值用于緩存 -128 - 127 之間的數字，如果有 -128 - 127 之間的數字的話，使用 new Integer 不用創建對象，會直接從緩存池中取，此操作會減少堆中對象的分配，有利于提高程序的運行效率。

例如創建一個 Integer a = 24，其實是調用 Integer 的valueOf，可以通過反編譯得出這個結論

然后我們看一下 valueOf 方法

如果在指定緩存池范圍內的話，會直接返回緩存的值而不用創建新的 Integer 對象。

緩存的大小可以使用XX:AutoBoxCacheMax來指定，在 VM 初始化時，java.lang.Integer.IntegerCache.high屬性會設置和保存在sun.misc.VM的私有系統屬性中。

UTF-8 和 Unicode 的關系

由于每個國家都有自己獨有的字符編碼，所以Unicode 的發展旨在創建一個新的標準，用來映射當今使用的大多數語言中的字符，這些字符有一些不是必要的，但是對于創建文本來說卻是不可或缺的。Unicode 統一了所有字符的編碼，是一個 Character Set，也就是字符集，字符集只是給所有的字符一個唯一編號，但是卻沒有規定如何存儲，不同的字符其存儲空間不一樣，有的需要一個字節就能存儲，有的則需要2、3、4個字節。

UTF-8 只是眾多能夠對文本字符進行解碼的一種方式，它是一種變長的方式。UTF-8 代表 8 位一組表示 Unicode 字符的格式，使用 1 - 4 個字節來表示字符。

U+ 0000 ~ U+ 007F: 0XXXXXXX
U+ 0080 ~ U+ 07FF: 110XXXXX 10XXXXXX
U+ 0800 ~ U+ FFFF: 1110XXXX 10XXXXXX 10XXXXXX
U+10000 ~ U+1FFFF: 11110XXX 10XXXXXX 10XXXXXX 10XXXXXX

可以看到，UTF-8 通過開頭的標志位位數實現了變長。對于單字節字符，只占用一個字節，實現了向下兼容 ASCII，并且能和 UTF-32 一樣，包含 Unicode 中的所有字符，又能有效減少存儲傳輸過程中占用的空間。

項目為 UTF-8 環境，char c = '中'，是否合法

可以，因為 Unicode 編碼采用 2 個字節的編碼，UTF-8 是 Unicode 的一種實現，它使用可變長度的字符集進行編碼，char c = '中' 是兩個字節，所以能夠存儲。合法。

Arrays.asList 獲得的 List 應該注意什么

Arrays.asList是 Array 中的一個靜態方法，它能夠實現把數組轉換成為 List 序列，需要注意下面幾點

Arrays.asList 轉換完成后的 List 不能再進行結構化的修改，什么是結構化的修改？就是不能再進行任何 List 元素的增加或者減少的操作。

public?static?void?main(String[]?args)?{
??Integer[]?integer?=?new?Integer[]?{?1,?2,?3,?4?};
??List?integetList?=?Arrays.asList(integer);
??integetList.add(5);
}

結果會直接拋出

Exception?in?thread?"main"?java.lang.UnsupportedOperationException

我們看一下源碼就能發現問題

//?這是?java.util.Arrays?的內部類，而不是?java.util.ArrayList?
private?static?class?ArrayList<E>?extends?AbstractList<E>implements?RandomAccess,?java.io.Serializable

繼承 AbstractList 中對 add、remove、set 方法是直接拋異常的，也就是說如果繼承的子類沒有去重寫這些方法，那么子類的實例去調用這些方法是會直接拋異常的。

下面是AbstractList中方法的定義，我們可以看到具體拋出的異常：

public?void?add(int?index,?E?element)?{
??throw?new?UnsupportedOperationException();
}
public?E?remove(int?index)?{
??throw?new?UnsupportedOperationException();
}
public?E?set(int?index,?E?element)?{
??throw?new?UnsupportedOperationException();
}

雖然 set 方法也拋出了一場，但是由于內部類 ArrayList 重寫了 set 方法，所以支持其可以對元素進行修改。

Arrays.asList 不支持基礎類型的轉換

Java 中的基礎數據類型(byte,short,int,long,float,double,boolean)是不支持使用 Arrays.asList 方法去轉換的

Collection 和 Collections 的區別

Collection 和 Collections 都是位于java.util包下的類

Collection 是集合類的父類，它是一個頂級接口，大部分抽象類比如說AbstractList、AbstractSet都繼承了 Collection 類，Collection 類只定義一節標準方法比如說 add、remove、set、equals 等，具體的方法由抽象類或者實現類去實現。

Collections 是集合類的工具類，Collections 提供了一些工具類的基本使用

sort 方法，對當前集合進行排序, 實現 Comparable 接口的類，只能使用一種排序方案，這種方案叫做自然比較
比如實現線程安全的容器Collections.synchronizedList、Collections.synchronizedMap等
reverse 反轉，使用 reverse 方法可以根據元素的自然順序對指定列表按降序進行排序。
fill，使用指定元素替換指定列表中的所有元素。

有很多用法，讀者可以翻閱 Collections 的源碼查看，Collections 不能進行實例化，所以 Collections 中的方法都是由Collections.方法直接調用。

你知道 fail-fast 和 fail-safe 嗎

fail-fast是 Java 中的一種快速失敗機制，java.util 包下所有的集合都是快速失敗的，快速失敗會拋出ConcurrentModificationException異常，fail-fast 你可以把它理解為一種快速檢測機制，它只能用來檢測錯誤，不會對錯誤進行恢復，fail-fast 不一定只在多線程環境下存在，ArrayList 也會拋出這個異常，主要原因是由于modCount 不等于 expectedModCount。

fail-safe是 Java 中的一種安全失敗機制，它表示的是在遍歷時不是直接在原集合上進行訪問，而是先復制原有集合內容，在拷貝的集合上進行遍歷。由于迭代時是對原集合的拷貝進行遍歷，所以在遍歷過程中對原集合所作的修改并不能被迭代器檢測到，所以不會觸發 ConcurrentModificationException。java.util.concurrent包下的容器都是安全失敗的，可以在多線程條件下使用，并發修改。

ArrayList、LinkedList 和 Vector 的區別

這也是一道老生常談的問題了

ArrayList、LinkedList、Vector都是位于java.util包下的工具類，它們都實現了 List 接口。

ArrayList 的底層是動態數組，它是基于數組的特性而演變出來的，所以ArrayList 遍歷訪問非常快，但是增刪比較慢，因為會涉及到數組的拷貝。ArrayList 是一個非線程安全的容器，在并發場景下會造成問題，如果想使用線程安全的容器的話，推薦使用Collections.synchronizedList；ArrayList 在擴容時會增加 50% 的容量。
LinkedList 的底層是雙向鏈表，所以 LinkedList 的增加和刪除非常快，只需把元素刪除，把各自的指針指向新的元素即可。但是 LinkedList 遍歷比較慢，因為只有每次訪問一個元素才能知道下一個元素的值。LinkedList 也是一個非線程安全的容器，推薦使用Collections.synchronizedList
Vector 向量是最早出現的集合容器，Vector 是一個線程安全的容器，它的每個方法都粗暴的加上了synchronized鎖，所以它的增刪、遍歷效率都很低。Vector 在擴容時，它的容量會增加一倍。

Exception 和 Error 有什么區別

Exception 泛指的是異常，Exception 主要分為兩種異常，一種是編譯期出現的異常，稱為checkedException，一種是程序運行期間出現的異常，稱為uncheckedException，常見的 checkedException 有IOException，uncheckedException 統稱為RuntimeException，常見的 RuntimeException 主要有NullPointerException、IllegalArgumentException、ArrayIndexOutofBoundException等，Exception 可以被捕獲。

Error 是指程序運行過程中出現的錯誤，通常情況下會造成程序的崩潰，Error 通常是不可恢復的，Error 不能被捕獲。

詳細可以參考這篇文章看完這篇 Exception 和 Error ，和面試官扯皮就沒問題了

String、StringBuilder 和 StringBuffer 有什么區別

String 特指的是 Java 中的字符串，String 類位于java.lang包下，String 類是由 final 修飾的，String 字符串一旦創建就不能被修改，任何對 String 進行修改的操作都相當于重新創建了一個字符串。String 字符串的底層使用 StringBuilder 來實現的

StringBuilder 位于java.util包下，StringBuilder 是一非線程安全的容器，StringBuilder 的 append 方法常用于字符串拼接，它的拼接效率要比 String 中+號的拼接效率高。StringBuilder 一般不用于并發環境

StringBuffer 位于java.util包下，StringBuffer 是一個線程安全的容器，多線程場景下一般使用 StringBuffer 用作字符串的拼接

StringBuilder 和 StringBuffer 都是繼承于AbstractStringBuilder類，AbstractStringBuilder 類實現了 StringBuffer 和 StringBuilder 的常規操作。

動態代理是基于什么原理

代理一般分為靜態代理和動態代理，它們都是代理模式的一種應用，靜態代理指的是在程序運行前已經編譯好，程序知道由誰來執行代理方法。

而動態代理只有在程序運行期間才能確定，相比于靜態代理，動態代理的優勢在于可以很方便的對代理類的函數進行統一的處理，而不用修改每個代理類中的方法。可以說動態代理是基于反射實現的。通過反射我們可以直接操作類或者對象，比如獲取類的定義，獲取聲明的屬性和方法，調用方法，在運行時可以修改類的定義。

動態代理是一種在運行時構建代理、動態處理方法調用的機制。動態代理的實現方式有很多，Java 提供的代理被稱為JDK 動態代理，JDK 動態代理是基于類的繼承。

int 和 Integer 的區別

int 和 Integer 區別可就太多了

int 是 Java 中的基本數據類型，int 代表的是整型，一個 int 占 4 字節，也就是 32 位，int 的初始值是默認值是 0 ，int 在 Java 內存模型中被分配在棧中，int 沒有方法。
Integer 是 Java 中的基本數據類型的包裝類，Integer 是一個對象，Integer 可以進行方法調用，Integer 的默認值是 null，Integer 在 Java 內存模型中被分配在堆中。int 和 Integer 在計算時可以進行相互轉換，int -> Integer 的過程稱為裝箱，Integer -> int 的過程稱為拆箱，Integer 還有 IntegerCache ，會自動緩存 -128 - 127 中的值

Java 提供了哪些 I/O 方式

Java I/O 方式有很多種，傳統的 I/O 也稱為BIO，主要流有如下幾種

Java I/O 包的實現比較簡單，但是容易出現性能瓶頸，傳統的 I/O 是基于同步阻塞的。

JDK 1.4 之后提供了NIO，也就是位于java.nio包下，提供了基于channel、Selector、Buffer的抽象，可以構建多路復用、同步非阻塞 I/O 程序。

JDK 1.7 之后對 NIO 進行了進一步改進，引入了異步非阻塞的方式，也被稱為AIO(Asynchronous IO)。可以用生活中的例子來說明：項目經理交給手下員工去改一個 bug，那么項目經理不會一直等待員工解決 bug，他肯定在員工解決 bug 的期間給其他手下分配 bug 或者做其他事情，員工解決完 bug 之后再告訴項目經理 bug 解決完了。

談談你知道的設計模式

一張思維導圖鎮場

比如全局唯一性可以用單例模式。

可以使用策略模式優化過多的 if...else...

制定標準用模版模式

接手其他人的鍋，但不想改原來的類用適配器模式

使用組合而不是繼承

使用裝飾器可以制作加糖、加奶酪的咖啡

代理可以用于任何中間商......

Comparator 和 Comparable 有什么不同

Comparable 更像是自然排序
Comparator 更像是定制排序

同時存在時采用 Comparator(定制排序)的規則進行比較。

對于一些普通的數據類型(比如 String, Integer, Double…)，它們默認實現了Comparable 接口，實現了 compareTo 方法，我們可以直接使用。

而對于一些自定義類，它們可能在不同情況下需要實現不同的比較策略，我們可以新創建 Comparator 接口，然后使用特定的 Comparator 實現進行比較。

Object 類中一般都有哪些方法

Object 類是所有對象的父類，它里面包含一些所有對象都能夠使用的方法

hashCode()：用于計算對象的哈希碼
equals()：用于對象之間比較值是否相等
toString(): 用于把對象轉換成為字符串
clone(): 用于對象之間的拷貝
wait(): 用于實現對象之間的等待
notify(): 用于通知對象釋放資源
notifyAll(): 用于通知所有對象釋放資源
finalize(): 用于告知垃圾回收器進行垃圾回收
getClass(): 用于獲得對象類

Java 泛型和類型擦除

關于 Java 泛型和擦除看著一篇就夠了。http://softlab.sdut.edu.cn/blog/subaochen/2017/01/generics-type-erasure/

反射的基本原理，反射創建類實例的三種方式是什么

反射機制就是使 Java 程序在運行時具有自省(introspect)的能力，通過反射我們可以直接操作類和對象，比如獲取某個類的定義，獲取類的屬性和方法，構造方法等。

創建類實例的三種方式是

對象實例.getClass()；
通過 Class.forName() 創建
對象實例.newInstance() 方法創建

強引用、若引用、虛引用和幻象引用的區別

我們說的不同的引用類型其實都是邏輯上的，而對于虛擬機來說，主要體現的是對象的不同的可達性(reachable)狀態和對垃圾收集(garbage collector)的影響。

可以通過下面的流程來對對象的生命周期做一個總結

對象被創建并初始化，對象在運行時被使用，然后離開對象的作用域，對象會變成不可達并會被垃圾收集器回收。圖中用紅色標明的區域表示對象處于強可達階段。

JDK1.2 介紹了java.lang.ref包，對象的生命周期有四個階段：?強可達?(Strongly Reachable?)、軟可達(Soft Reachable?)、弱可達(Weak Reachable?)、幻象可達(Phantom Reachable?)。

如果只討論符合垃圾回收條件的對象，那么只有三種：軟可達、弱可達和幻象可達。

軟可達：軟可達就是?我們只能通過軟引用?才能訪問的狀態，軟可達的對象是由SoftReference引用的對象，并且沒有強引用的對象。軟引用是用來描述一些還有用但是非必須的對象。垃圾收集器會盡可能長時間的保留軟引用的對象，但是會在發生OutOfMemoryError之前，回收軟引用的對象。如果回收完軟引用的對象，內存還是不夠分配的話，就會直接拋出 OutOfMemoryError。
弱可達：弱可達的對象是WeakReference引用的對象。垃圾收集器可以隨時收集弱引用的對象，不會嘗試保留軟引用的對象。
幻象可達：幻象可達是由PhantomReference引用的對象，幻象可達就是沒有強、軟、弱引用進行關聯，并且已經被 finalize 過了，只有幻象引用指向這個對象的時候。

除此之外，還有強可達和不可達的兩種可達性判斷條件

強可達：就是一個對象剛被創建、初始化、使用中的對象都是處于強可達的狀態
不可達(unreachable)：處于不可達的對象就意味著對象可以被清除了。

下面是一個不同可達性狀態的轉換圖

判斷可達性條件，也是 JVM 垃圾收集器決定如何處理對象的一部分考慮因素。

所有的對象可達性引用都是java.lang.ref.Reference的子類，它里面有一個get()方法，返回引用對象。如果已通過程序或垃圾收集器清除了此引用對象，則此方法返回 null 。也就是說，除了幻象引用外，軟引用和弱引用都是可以得到對象的。而且這些對象可以人為拯救，變為強引用，例如把 this 關鍵字賦值給對象，只要重新和引用鏈上的任意一個對象建立關聯即可。

final、finally 和 finalize() 的區別

這三者可以說是沒有任何關聯之處，我們上面談到了，final 可以用來修飾類、變量和方法，可以參考上面 final 的那道面試題。

finally 是一個關鍵字，它經常和 try 塊一起使用，用于異常處理。使用 try...finally 的代碼塊種，finally 部分的代碼一定會被執行，所以我們經常在 finally 方法中用于資源的關閉操作。

JDK1.7 中，推薦使用try-with-resources優雅的關閉資源，它直接使用 try(){} 進行資源的關閉即可，就不用寫 finally 關鍵字了。

finalize 是 Object 對象中的一個方法，用于對象的回收方法，這個方法我們一般不推薦使用，finalize 是和垃圾回收關聯在一起的，在 Java 9 中，將 finalize 標記為了deprecated，如果沒有特別原因，不要實現 finalize 方法，也不要指望他來進行垃圾回收。

內部類有哪些分類，分別解釋一下

在 Java 中，可以將一個類的定義放在另外一個類的定義內部，這就是內部類。內部類本身就是類的一個屬性，與其他屬性定義方式一致。

內部類的分類一般主要有四種

成員內部類
局部內部類
匿名內部類
靜態內部類

靜態內部類就是定義在類內部的靜態類，靜態內部類可以訪問外部類所有的靜態變量，而不可訪問外部類的非靜態變量；

成員內部類就是定義在類內部，成員位置上的非靜態類，就是成員內部類。成員內部類可以訪問外部類所有的變量和方法，包括靜態和非靜態，私有和公有。

定義在方法中的內部類，就是局部內部類。定義在實例方法中的局部類可以訪問外部類的所有變量和方法，定義在靜態方法中的局部類只能訪問外部類的靜態變量和方法。

匿名內部類就是沒有名字的內部類，除了沒有名字，匿名內部類還有以下特點：

匿名內部類必須繼承一個抽象類或者實現一個接口
匿名內部類不能定義任何靜態成員和靜態方法。
當所在的方法的形參需要被匿名內部類使用時，必須聲明為 final。
匿名內部類不能是抽象的，它必須要實現繼承的類或者實現的接口的所有抽象方法。

說出幾種常用的異常

NullPointerException: 空指針異常
NoSuchMethodException：找不到方法
IllegalArgumentException：不合法的參數異常
IndexOutOfBoundException: 數組下標越界異常
IOException：由于文件未找到、未打開或者I/O操作不能進行而引起異常
ClassNotFoundException ：找不到文件所拋出的異常
NumberFormatException：字符的UTF代碼數據格式有錯引起異常；
InterruptedException：線程中斷拋出的異常

靜態綁定和動態綁定的區別

一個Java 程序要經過編寫、編譯、運行三個步驟，其中編寫代碼不在我們討論的范圍之內，那么我們的重點自然就放在了編譯和運行這兩個階段，由于編譯和運行階段過程相當繁瑣，下面就我的理解來進行解釋：

Java 程序從源文件創建到程序運行要經過兩大步驟：

1、編譯時期是由編譯器將源文件編譯成字節碼的過程

2、字節碼文件由Java虛擬機解釋執行

綁定

綁定就是一個方法的調用與調用這個方法的類連接在一起的過程被稱為綁定。

綁定主要分為兩種：

靜態綁定和動態綁定

綁定的其他叫法

靜態綁定 ?== 前期綁定 == 編譯時綁定

動態綁定 ?== 后期綁定 == 運行時綁定

為了方便區分：下面統一稱呼為靜態綁定和動態綁定

靜態綁定

在程序運行前，也就是編譯時期 JVM 就能夠確定方法由誰調用，這種機制稱為靜態綁定

識別靜態綁定的三個關鍵字以及各自的理解

如果一個方法由 private、static、final 任意一個關鍵字所修飾，那么這個方法是前期綁定的

構造方法也是前期綁定

private：private 關鍵字是私有的意思，如果被 private 修飾的方法是無法由本類之外的其他類所調用的，也就是本類所特有的方法，所以也就由編譯器識別此方法是屬于哪個類的

public?class?Person?{

????private?String?talk;

????private?String?canTalk(){
????????return?talk;
????}
}

class?Animal{

????public?static?void?main(String[]?args)?{
????????Person?p?=?new?Person();
????????//?private?修飾的方法是Person類獨有的，所以Animal類無法訪問(動物本來就不能說話)
//????????p.canTalk();
????}
}

final：final 修飾的方法不能被重寫，但是可以由子類進行調用，如果將方法聲明為 final 可以有效的關閉動態綁定

public?class?Fruit?{

????private?String?fruitName;

????final?String?eatingFruit(String?name){
????????System.out.println("eating?"?+?name);
????????return?fruitName;
????}
}

class?Apple?extends?Fruit{

??????//?不能重寫final方法，eatingFruit方法只屬于Fruit類，Apple類無法調用
//????String?eatingFruit(String?name){
//????????super.eatingFruit(name);
//????}

????String?eatingApple(String?name){
????????return?super.eatingFruit(name);
????}
}

static：static 修飾的方法比較特殊，不用通過 new 出某個類來調用，由類名.變量名直接調用該方法，這個就很關鍵了，new 很關鍵，也可以認為是開啟多態的導火索，而由類名.變量名直接調用的話，此時的類名是確定的，并不會產生多態，如下代碼：

public?class?SuperClass?{

????public?static?void?sayHello(){
????????
????????System.out.println("由?superClass?說你好");
????}
}

public?class?SubClass?extends?SuperClass{

????public?static?void?sayHello(){
????????System.out.println("由?SubClass?說你好");
????}

????public?static?void?main(String[]?args)?{
????????SuperClass.sayHello();
????????SubClass.sayHello();
????}
}

SubClass 繼承 SuperClass 后，在

是無法重寫 sayHello 方法的，也就是說 sayHello() 方法是對子類隱藏的，但是你可以編寫自己的 sayHello() 方法，也就是子類 SubClass 的sayHello() 方法，由此可見，方法由 static 關鍵詞所修飾，也是編譯時綁定

動態綁定

在運行時根據具體對象的類型進行綁定

除了由 private、final、static 所修飾的方法和構造方法外，JVM 在運行期間決定方法由哪個對象調用的過程稱為動態綁定

如果把編譯、運行看成一條時間線的話，在運行前必須要進行程序的編譯過程，那么在編譯期進行的綁定是前期綁定，在程序運行了，發生的綁定就是后期綁定

public?class?Father?{

????void?drinkMilk(){
????????System.out.println("父親喜歡喝牛奶");
????}
}

public?class?Son?extends?Father{

????@Override
????void?drinkMilk()?{
????????System.out.println("兒子喜歡喝牛奶");
????}

????public?static?void?main(String[]?args)?{
????????Father?son?=?new?Son();
????????son.drinkMilk();
????}
}

Son 類繼承 Father 類，并重寫了父類的 dringMilk() 方法，在輸出結果得出的是兒子喜歡喝牛奶。那么上面的綁定方式是什么呢？

上面的綁定方式稱之為動態綁定，因為在你編寫 Father son = new Son() 的時候，編譯器并不知道 son 對象真正引用的是誰，在程序運行時期才知道，這個 son 是一個 Father 類的對象，但是卻指向了 Son 的引用，這種概念稱之為多態，那么我們就能夠整理出來多態的三個原則：

繼承
重寫
父類對象指向子類引用

也就是說，在 Father son = new Son() ，觸發了動態綁定機制。

動態綁定的過程

虛擬機提取對象的實際類型的方法表；

虛擬機搜索方法簽名；

調用方法。

動態綁定和靜態綁定的特點

靜態綁定

靜態綁定在編譯時期觸發，那么它的主要特點是

1、編譯期觸發，能夠提早知道代碼錯誤

2、提高程序運行效率

動態綁定

1、使用動態綁定的前提條件能夠提高代碼的可用性，使代碼更加靈活。

2、多態是設計模式的基礎，能夠降低耦合性。

- END -點擊圖片參與活動，免費包郵送書??????

●??人人都欠微軟一個正版？

●??腳本之家粉絲福利，請查看！

●??2020年開發者生態報告：Python超越Java

●?Java 中的 String 有沒有長度限制？

●?小白，你要的Java抽象類，操碎了心！

C、Java：我看著你們，滿懷敬意

總結

以上是生活随笔為你收集整理的java 多态判断非空_收藏Java 面试题全梳理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。