理解Java集合框架裏面的的transient關鍵字(轉)
轉自https://my.oschina.net/u/1027043/blog/1627441
在分析HashMap和ArrayList的源碼時,我們會發現裏面存儲數據的數組都是用transient關鍵字修飾的,如下:
HashMap裏面的:
transient Node<K,V>[] table;
ArrayList裏面的:
transient Object[] elementData
既然用transient修飾,那就說明這個數組是不會被序列化的,那麽同時我們發現了這兩個集合都自定義了獨自的序列化方式:
先看HashMap自定義的序列化的代碼:
//1
private void writeObject(java.io.ObjectOutputStream s)
throws IOException {
int buckets = capacity();
// Write out the threshold, loadfactor, and any hidden stuff
s.defaultWriteObject();
s.writeInt(buckets);
s.writeInt(size);
internalWriteEntries(s);
}
//2
public void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
Node<K,V>[] tab;
if (size > 0 && (tab = table) != null) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
s.writeObject(e.key);
s.writeObject(e.value);
}
}
}
}
再看HashMap自定義的反序列化的代碼:
//1
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
// Read in the threshold (ignored), loadfactor, and any hidden stuff
s.defaultReadObject();
reinitialize();
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
s.readInt(); // Read and ignore number of buckets
int mappings = s.readInt(); // Read number of mappings (size)
if (mappings < 0)
throw new InvalidObjectException("Illegal mappings count: " +
mappings);
else if (mappings > 0) { // (if zero, use defaults)
// Size the table using given load factor only if within
// range of 0.25...4.0
float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
float fc = (float)mappings / lf + 1.0f;
int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
DEFAULT_INITIAL_CAPACITY :
(fc >= MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY :
tableSizeFor((int)fc));
float ft = (float)cap * lf;
threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
(int)ft : Integer.MAX_VALUE);
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
table = tab;
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
這裏面我們看到HashMap的源碼裏面自定義了序列化和反序列化的方法,序列化方法主要是把當前HashMap的buckets數量,size和裏面的k,v對一一給寫到了對象輸出流裏面,然後在反序列化的時候,再從流裏面一一的解析出來,然後又重新恢復出了HashMap的整個數據結構。
接著我們看ArrayList裏面自定義的序列化的實現:
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
然後反序列化的實現:
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
ArrayList裏面也是把其size和裏面不為null的數據給寫到流裏面,然後在反序列化的時候重新使用數據把數據結構恢復出來。
那麽問題來了,為什麽他們明明都實現了Serializable接口,已經具備了自動序列化的功能,為啥還要重新實現序列化和反序列化的方法呢?
(1)HashMap中實現序列化和反序列化的原因:
在HashMap要定義自己的序列化和反序列化實現,有一個重要的因素是因為hashCode方法是用native修飾符修飾的,也就是用它跟jvm的運行環境有關,Object類中的hashCode源碼如下:
public native int hashCode();
也就是說不同的jvm虛擬機對於同一個key產生的hashCode可能是不一樣的,所以數據的內存分布可能不相等了,舉個例子,現在有兩個jvm虛擬機分別是A和B,他們對同一個字符串x產生的hashCode不一樣:
所以導致:
在A的jvm中它的通過hashCode計算它在table數組中的位置是3
在B的jvm中它的通過hashCode計算它在table數組中的位置是5
這個時候如果我們在A的jvm中按照默認的序列化方式,那麽位置屬性3就會被寫入到字節流裏面,然後通過B的jvm來反序列化,同樣會把這條數據放在table數組中3的位置,然後我們在B的jvm中get數據,由於它對key的hashCode和A不一樣,所以它會從5的位置取值,這樣以來就會讀取不到數據。
如何解決這個問題,首先導致上面問題的主要原因在於因為hashCode的不一樣從而可能導致內存分布不一樣,所以只要在序列化的時候把跟hashCode有關的因素比如上面的位置屬性給排除掉,就可以解決這個問題。
最簡單的辦法就是在A的jvm把數據給序列化進字節流,而不是一刀切把數組給序列化,之後在B的jvm中反序列化時根據數據重新生成table的內存分布,這樣就來就完美解決了這個問題。
(2)ArrayList中實現序列化和反序列化的原因:
在ArrayList中,我們知道數組的長度會隨著數據的插入而不斷的動態擴容,每次擴容都需要增加原數組一半的長度,這而一半的長度極端情況下都是null值,所以在序列化的時候可以把這部分數據排除出去,從而節省時間和空間:
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
註意ArrayList在序列化的時候用的size來遍歷原數組中的元素,而並不是elementData.length也就是數組的長度,而size的大小就是數組裏面非null元素的個數,所以這裏才采用了自定義序列化的方式。
到這裏細心的朋友可能有個疑問:HashMap中也就是采用的動態數組擴容為什麽它在序列化的時候用的是table.length而不是size呢,這其實很容易回答在HashMap中table.length必須是2的n次方,而且這個值會決定了好幾個參數的值,所以如果也把null值給去掉,那麽必須要重新的估算table.length的值,有可能造成所有數據的重新分布,所以最好的辦法就是保持原樣。
註意上面的null值,指的是table裏面Node元素是null,而並不是HashMap裏面的key等於null,而key是Node裏面的一個字段。
總結:
本文主要介紹了在HashMap和ArrayList中其核心的數據結構字段為什麽用transient修飾並分別介紹了其原因,所以使用序列化時,應該謹記effective java中的一句話:當一個對象的物理表示方法與它的邏輯數據內容有實質性差別時,使用默認序列化形式有N種缺陷,所以應該盡可能的根據實際情況重寫序列化方法。
理解Java集合框架裏面的的transient關鍵字(轉)