關於Java Guava ImmutableMap不可變集合源碼分析
Java Guava不可變集合ImmutableMap的源碼分析
一、案例場景
遇到過這樣的場景，在定義一個static修飾的Map時，使用瞭大量的put()方法賦值，就類似這樣——
public static final Map<String,String> dayMap= new HashMap<>();
static {
dayMap.put("Monday","今天上英語課");
dayMap.put("Tuesday","今天上語文課");
dayMap.put("Wednesday","今天上數學課");
dayMap.put("Thursday","今天上音樂課");
dayMap.put("Sunday","今天上編程課");
......
}
當時，我就在想，是否可以進一步優化下，使得代碼看起來更為優雅些，然後，就發現瞭Google Guava裡的有一個類ImmutableMap，通過這個類可以實現類似建造者模式的鏈式編程，優化後的效果，如下：
public static final Map<String,String> dayMap = ImmutableMap.<String, String>builder()
.put("Monday","今天上英語課")
.put("Tuesday","今天上語文課")
.put("Wednesday","今天上數學課")
.put("Thursday","今天上音樂課")
.put("Sunday","今天上編程課")
.build();
二、ImmutableMap源碼分析
那麼，這個ImmutableMap究竟是如何實現這樣的功能呢？
在Google Guava官方教程中，Immutable前綴的集合被定義為不可變集合，包括ImmutableSet、 ImmutableMap等，何為不可變集合？就是指，在集合創建後，集合裡所有的狀態在生命周期內都不可再修改瞭，隻能讀。
那麼，什麼是可再修改的呢，像Jdk中的map、list等，創建後，還可以再通過put()或者add()反復新增或者修改，這種就是可再修改的集合。既然是不可再修改集合，是不是就一定不能再修改瞭呢？也不是，其實，通過反射還是可以被修改的，但這已經不是不可變集合之所以存在的初衷瞭。
總結一句話是，不可變集合是線程安全的且可當成常量使用的。
接下來，就進入到ImmutableMap內部，可以看到，其實現瞭Map接口，跟HashMap有點類似地方在於，Map接口都算是他們的基類，都可以實現父類引用指向子類對象，即向上轉型。
public abstract class ImmutableMap<K, V> implements Map<K, V>, Serializable {}
這是一個抽象類，若要實現這樣調用 ImmutableMap.<String, String>builder()，表面上就可以猜測到<String, String>builder()一定是被static定義的靜態方法，進到源碼裡，發現確實如此——
/**
* Returns a new builder. The generated builder is equivalent to the builder
* created by the {@link Builder} constructor.
*/
public static <K, V> Builder<K, V> builder() {
return new Builder<K, V>();
}
這個方法的定義對於一些初級程序員而言，可能會覺得很奇怪，其實這個方法格式的本質是這樣的 ——
public <T> T method(T t)
這是一種泛型的約定規范，第一個定義一種泛型，表示當前方法有一個范型變量類型，用T表示；第二個T是表示method的返回類型為T。
回過頭來看這個builder()方法，就很好理解瞭，<K, V>是定義一種泛型，表示當前方法的泛型變量，Builder<K, V>表示返回一個泛型變量為<K, V>的對象。
前面定義 ImmutableMap.<String, String>builder()，在這個builder()方法裡，就會返回一個new Builder<String, String>()的對象，這個對象通過構造器，初始化瞭一個大小為ImmutableCollection.Builder.DEFAULT_INITIAL_CAPACITY的數組entries，而這個DEFAULT_INITIAL_CAPACITY的默認值是4。
public static class Builder<K, V> {
Comparator<? super V> valueComparator;
ImmutableMapEntry<K, V>[] entries;
int size;
boolean entriesUsed;
public Builder() {
this(ImmutableCollection.Builder.DEFAULT_INITIAL_CAPACITY);
}
Builder(int initialCapacity) {
this.entries = new ImmutableMapEntry[initialCapacity];
this.size = 0;
this.entriesUsed = false;
}
......
}
那麼問題來瞭，這個 ImmutableMapEntry<K, V>[] 是什麼類型的數組呢？
這個ImmutableMapEntry<K, V>類 ，是繼承一個ImmutableEntry<K, V>類 ——
class ImmutableMapEntry<K, V> extends ImmutableEntry<K, V> {
static <K, V> ImmutableMapEntry<K, V>[] createEntryArray(int size) {
return new ImmutableMapEntry[size];
}
ImmutableMapEntry(K key, V value) {
super(key, value);
checkEntryNotNull(key, value);
}
}
註意一點， checkEntryNotNull(key, value)做瞭一個校驗，這就意味著，存入的key和value值都不能為空。
static void checkEntryNotNull(Object key, Object value) {
if (key == null) {
throw new NullPointerException("null key in entry: null=" + value);
} else if (value == null) {
throw new NullPointerException("null value in entry: " + key + "=null");
}
}
在父類ImmutableEntry<K, V>類裡，定義瞭key和value兩個泛型變量，可見，當外部調用builder().put(key，value)來存儲key-value數據時，其實是將key-value數據存儲到ImmutableEntry對象的key與value裡。
class ImmutableEntry<K, V> extends AbstractMapEntry<K, V> implements Serializable {
final K key;
final V value;
......
}
提到ImmutableEntry<K, V>數組來存儲key-value數據，就不得不提一下HashMap。
在JDK1.8當中，HashMap是由數組+鏈表+紅黑樹組成，它內部的數組是由Node<K,V>[]定義，而這個 Node<K,V> 實現的是Map.Entry<K,V>——
ImmutableMapEntry<K, V>頂部同樣是實現瞭Entry<K,V>——
可見，ImmutableMap與HashMap一樣，其存儲key-value的對象所屬的類，都直接或者間接地實現瞭Entry<K,V>接口。
分析到這裡，再看回Builder<K, V>類源碼，就很容易明白 ，這個ImmutableMapEntry<K, V>[] entries與HashMap的數組類似，都是用來存儲key-value的數據。
接下來，就是分析put的邏輯原理瞭。
前面分析到的Builder類，其實是屬於抽象類 ImmutableMap<K, V>中的內部靜態類，這就意味著，執行ImmutableMap.<String, String>builder().put(“Monday”,”今天上英語課”)的本質，其實是相當於執行瞭ImmutableMap.new Builder<K, V>().put(“Monday”,”今天上英語課”)。
put方法的源碼如下：
public Builder<K, V> put(K key, V value) {
ensureCapacity(size + 1);
ImmutableMapEntry<K, V> entry = entryOf(key, value);
// don't inline this: we want to fail atomically if key or value is null
entries[size++] = entry;
return this;
}
1、先看第一行代碼調用的方法，其作用是判斷當新增一個key-value對象存到數組時，是否會有溢出的可能，若出現溢出的情況，就先對數組進行擴容。
private void ensureCapacity(int minCapacity) {
if (minCapacity > entries.length) {
entries =
Arrays.copyOf(
entries, ImmutableCollection.Builder.expandedCapacity(entries.length, minCapacity));
entriesUsed = false;
}
}
2、第二行ImmutableMapEntry<K, V> entry = entryOf(key, value)就是創建一個新的ImmutableMapEntry對象，通過構造器初始化賦值給對象的key與value——
static <K, V> ImmutableMapEntry<K, V> entryOf(K key, V value) {
return new ImmutableMapEntry<K, V>(key, value);
}
3、第三行代碼 entries[size++] = entry是將新增的ImmutableMapEntry對象存儲到數組空閑的位置上，這樣通過put(key，value)緩存進來的key-value值，就通過對象的形式存入到瞭數組當中。
4、最後一行，是返回一個this，ImmutableMap能實現鏈式編程的原因，就是在這個this上。
- 當理解瞭這個this，就會理解ImmutableMap設計的精妙之處。
- 當我們使用鏈式編程ImmutableMap.<String, String>builder().put(“key1″,”value1”).put(“key2″,”value2”) .put(“key2″,”value3”)來賦值時，其內部就是反復調用瞭內部靜態類Builder當中的put()方法，那麼問題來瞭，為什麼能反復調用呢？
- 答案就是這個返回的this，其返回的還是Builder對象本身啊，Builderd對象當然可以繼續調用其put方法瞭。在這個反復調用的過程中， 隻有entries[size++] 是一直在新增變化的。
- 這其實是建造者設計模式的一種體現，隻不過平常遇到的建造者設計模式，大多都是將對象的各個屬性靈活進行拼裝，組成一個定制化的對象，而這裡，則是靈活去定制化一個數組存儲情況。
最後就是，就是執行.build()方法瞭——
ImmutableMap.<String, String>builder()
.put("Monday","今天上英語課")
......
.build();
這個build()源碼裡寫的很復雜，這裡直接簡單優化瞭下，大概意思，就是將entries數組包裝成一個實現Map接口的子對象進行返回。
public ImmutableMap<K, V> build() {
switch (size) {
case 0:
return of();
case 1:
return new SingletonImmutableBiMap<K, V>(k1, v1);
default:
return new RegularImmutableMap<K, V>(entries, table, mask);
}
}
當數組長度超過1時，其可以返回SingletonImmutableBiMap或者RegularImmutableMap，兩者都是間接實現瞭Map接口，對比一下各自的類定義——
final class SingletonImmutableBiMap<K, V> extends ImmutableBiMap<K, V> {
final transient K singleKey;
final transient V singleValue;
......
}
final class RegularImmutableMap<K, V> extends ImmutableMap<K, V> {
// entries in insertion order
private final transient Entry<K, V>[] entries;
// array of linked lists of entries
private final transient ImmutableMapEntry<K, V>[] table;
// 'and' with an int to get a table index
private final transient int mask;
......
}
發現，都有一個共同特點，類與類中的屬性，都是以final修飾符來定義的，這就意味著，一旦調用build()方法創建初始化後，就不可以再改變瞭。
這就是ImmutableMap集合不可變的真正原因所在。
最後，還有一個問題是，當通過ImmutableMap創建完成一個Map對象後，再試圖通過put來插入數據時，會發生什麼情況呢？
這時，再通過put方法調用時，例如，以上邊定義的dayMap為例，在某個方法裡，再試圖通過dayMap..put(“Monday”,”今天上英語課”) 來修改或者新增map數據時，這裡調用的put就已經不是內部類Builder<K, V>()裡的put方法瞭，而是ImmutableMap本身的put方法，這個方法的源碼如下——
/**
* Guaranteed to throw an exception and leave the map unmodified.
*
* @throws UnsupportedOperationException always
* @deprecated Unsupported operation.
*/
@CanIgnoreReturnValue
@Deprecated
@Override
public final V put(K k, V v) {
throw new UnsupportedOperationException();
}
其註釋表示，map unmodified，即無法再被修改，若仍調用put執行，隻會喜提一個異常 UnsupportedOperationException。
以上就是關於Java Guava ImmutableMap不可變集合源碼分析的詳細內容，更多關於Java Guava ImmutableMap的資料請關註WalkonNet其它相關文章！
推薦閱讀：
- java ImmutableMap的使用說明
- 解析Java中的static關鍵字
- Java Map.entry案例詳解
- HashMap在JDK7與JDK8中的實現過程解析
- Java效率提升神器之Guava-Joiner