Arraylist的elementData修饰关键词transient到底要闹哪样

Java代码  

1. private transient E[] elementData;  

 声明为transient，为什么还可以序列化成功呢？

我的回答是ArrayList重写了

Java代码  

1. private void writeObject(java.io.ObjectOutputStream s)  
2.         throws java.io.IOException{  
3.     int expectedModCount = modCount;  
4.     // Write out element count, and any hidden stuff  
5.     s.defaultWriteObject();  
6.   
7.         // Write out array length  
8.         s.writeInt(elementData.length);  
9.   
10.     // Write out all elements in the proper order.  
11.     for (int i=0; i<size; i++)  
12.             s.writeObject(elementData[i]);  
13.   
14.     if (modCount != expectedModCount) {  
15.         throw new ConcurrentModificationException();  
16.     }  
17.     }  

 在使用ObjectOutputStream序列化对象时会调用这个writeObject方法。

 

第二个问题是为什么要声明为transient呢？

在google了下，发现主流说法如下：

Java代码  

1. ArrayList实现了java.io.Serializable接口，所以ArrayList对象可以序列化到持久存储介质中。ArrayList的主要属性定义如下：  
2.   
3.     * private static final long serialVersionUID = 8683452581122892189L;  
4.     * private transient Object elementData[];  
5.     * private int size;  
6.   
7.   
8. 可以看出serialVersionUID和size都将自动序列化到介质中，但elementData数组对象却定义为transient了。  
9. 也就是说 ArrayList中的所有这些元素都不会自动系列化到介质中。为什么要这样实现？因为elementData数组中存储的  
10. “元素”其实仅是对这些元素的一个引用，并不是真正的对象，序列化一个对象的引用是毫无意义的，因为序列化是为了  
11. 反序列化，当你反序列化时，这些对象的引用已经不可能指向原来的对象了。所以在这儿需要手工的对ArrayList的元素进  
12. 行序列化操作。这就是writeObject()的作用。  

 果真如此么？？？？？？

验证下：

把ArrayList的内容完全copy到一个新类里面，命名为MyArrayList，如下：

Java代码  

1. public class MyArrayList<E> extends AbstractList<E>  
2.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable  
3. {  
4.     private static final long serialVersionUID = 8683452581122892189L;  
5.   
6.     /** 
7.      * The array buffer into which the elements of the ArrayList are stored. 
8.      * The capacity of the ArrayList is the length of this array buffer. 
9.      */  
10.     private E[] elementData;  
11.   
12.    。。。。。。。。  
13.   
14.    private void writeObject(java.io.ObjectOutputStream s)  
15.         throws java.io.IOException{  
16.     int expectedModCount = modCount;  
17.     // Write out element count, and any hidden stuff  
18.     s.defaultWriteObject();  
19.   
20.     if (modCount != expectedModCount) {  
21.         throw new ConcurrentModificationException();  
22.     }  
23.     }  
24.   
25.     /** 
26.      * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is, 
27.      * deserialize it). 
28.      */  
29.     private void readObject(java.io.ObjectInputStream s)  
30.         throws java.io.IOException, ClassNotFoundException {  
31.     // Read in size, and any hidden stuff  
32.     s.defaultReadObject();  
33.      }  
34.   
35. }  

 把transient去掉，write/readObject采用默认方式。

测试下MyArraylist序列化功能：

Java代码  

1. MyArrayList al = new MyArrayList<String>();  
2.         al.add("sssssssssssssssss");  
3.         al.add("bbbbbbbbbbbbbbbbbbt");  
4.         al.add("gggggggggggggggggg");  
5.           
6.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\al.tmp"));  
7.         oos.writeObject(al);  
8.           
9.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\al.tmp"));  
10.           
11.         MyArrayList<String> a = (MyArrayList<String>)ois.readObject();  
12.         for(String s: a)  
13.         {  
14.             System.out.println(s);  
15.         }  

 输出结果为：

Java代码  

1. sssssssssssssssss  
2. bbbbbbbbbbbbbbbbbbt  
3. gggggggggggggggggg  

 

到此证明：引用序列化无效的说法是错误的，这点在ObjectOutputStream中也有说明。

 

那是为什么呢？

既然是数组，要序列化到文件中，那就单独测试下数组对象的序列化和反序列化吧

Java代码  

1.               String[] stra = new String[4];  
2. stra[0] = "mmmmmmmmmm";  
3. stra[2] = "nnnnnnnnnn";  
4.   
5. oos = new ObjectOutputStream(new FileOutputStream("D:\\sa.tmp"));  
6. oos.writeObject(stra);  
7.   
8. ois = new ObjectInputStream(new FileInputStream("D:\\sa.tmp"));  
9.   
10. String[] str  = (String[])ois.readObject();  
11. for(String s: str)  
12. {  
13.     System.out.println(s);  
14. }  

 输出结果为：

Java代码  

1. mmmmmmmmmm  
2. null  
3. nnnnnnnnnn  
4. null  

 

从输出结果来看，数组序列化时，不管是否有值，都会将整个数组序列化到文件中。

由此可以看出，比较靠谱的原因是：

ArrayList是会开辟多余空间来保存数据的，而系列化和反序列化这些没有存放数据的空间是要消耗更多资源的，所以ArrayList的数组就声明为transient，告诉虚拟机这个你别管，我自己来处理，然后就自己实现write/readObject方法，仅仅系列化已经存放的数据。