我們都知道一個物件只要實現了Serilizable介面，這個物件就可以被序列化，java的這種序列化模式為開發者提供了很多便利，我們可以不必關係具體序列化的過程，只要這個類實現了Serilizable介面，這個的所有屬性和方法都會自動序列化。

     然而在實際開發過程中，我們常常會遇到這樣的問題，這個類的有些屬性需要序列化，而其他屬性不需要被序列化。java的transient關鍵字為我們提供了便利，你只需要實現Serilizable介面，將不需要序列化的屬性前新增關鍵字transient，序列化物件的時候，這個屬性就不會序列化到指定的目的地中。

Java的ArrayList中,定義了一個數組elementData用來裝載物件的

1. /** 
2.  * The array buffer into which the elements of the ArrayList are stored. 
3.  * The capacity of the ArrayList is the length of this array buffer. Any 
4.  * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 
5.  * will be expanded to DEFAULT_CAPACITY when the first element is added.
    
6.  */
7. transient Object[] elementData; // non-private to simplify nested class access

1. /** 
2.  * Save the state of the <tt>ArrayList</tt> instance to a stream (that 
3.  * is, serialize it). 
4.  * 
5.  * @serialData The length of the array backing the <tt>ArrayList</tt> 
6.  *             instance is emitted (int), followed by all of its elements 
7.  *             (each an <tt>Object</tt>) in the proper order. 
8.  */
9. privatevoid writeObject(java.io.ObjectOutputStream s)  
10.     throws java.io.IOException{  
11.     // Write out element count, and any hidden stuff
12.     int expectedModCount = modCount;  
13.     s.defaultWriteObject();  
14.     // Write out size as capacity for behavioural compatibility with clone()
15.     s.writeInt(size);  
16.     // Write out all elements in the proper order.
17.     for (int i=0; i<size; i++) {  
18.         s.writeObject(elementData[i]);  
19.     }  
20.     if (modCount != expectedModCount) {  
21.         thrownew ConcurrentModificationException();  
22.     }  
23. }  

1. /** 
2.  * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is, 
3.  * deserialize it). 
4.  */
5. privatevoid readObject(java.io.ObjectInputStream s)  
6.     throws java.io.IOException, ClassNotFoundException {  
7.     elementData = EMPTY_ELEMENTDATA;  
8.     // Read in size, and any hidden stuff
9.     s.defaultReadObject();  
10.     // Read in capacity
11.     s.readInt(); // ignored
12.     if (size > 0) {  
13.         // be like clone(), allocate array based upon size not capacity
14.         ensureCapacityInternal(size);  
15.         Object[] a = elementData;  
16.         // Read in all elements in the proper order.
17.         for (int i=0; i<size; i++) {  
18.             a[i] = s.readObject();  
19.         }  
20.     }  
21. }