/**
*ArrayList 的元素存儲在其中的數(shù)組緩沖區(qū)。
*ArrayList 的容量就是這個數(shù)組緩沖區(qū)的長度。添加第一個元素時，任何帶有 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的空 ArrayList 都將擴展為 DEFAULT_CAPACITY（10）。
*/
transient Object[] elementData;
// ArrayList 的大小
private int size;

public class UserInfo implements Serializable {
    private static final long serialVersionUID = 996890129747019948L;
    private String name;
    private transient String psw;
    public UserInfo(String name, String psw) {
        this.name = name;
        this.psw = psw;
    }
    public String toString() {
        return "name=" + name + ", psw=" + psw;
    }
}
public class TestTransient {
    public static void main(String[] args) {
        UserInfo userInfo = new UserInfo("張三", "123456");
        System.out.println(userInfo);
        try {
            // 序列化，被設(shè)置為transient的屬性沒有被序列化
            ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("UserInfo.out"));
            o.writeObject(userInfo);
            o.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            // 重新讀取內(nèi)容
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.out"));
            UserInfo readUserInfo = (UserInfo) in.readObject();
            // 讀取后psw的內(nèi)容為null
            System.out.println(readUserInfo.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
 * 構(gòu)造一個具有指定初始容量的空列表。
 */
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    }
}
/**
 * 構(gòu)造一個默認初始容量為10的空列表
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
 * 構(gòu)造一個包含指定集合元素的列表，按照集合的迭代器返回的順序。
 */
public ArrayList(Collection<? extends E> c) {
    Object[] a = c.toArray();
    if ((size = a.length) != 0) {
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        // 替換為空數(shù)組。
        elementData = EMPTY_ELEMENTDATA;
    }
}

// 用指定的元素替代此列表中指定位置上的元素，并返回以前位于該位置上的元素。
public E set(int index, E element) {
    RangeCheck(index);
    E oldValue = (E) elementData[index];
    elementData[index] = element;
    return oldValue;
}
// 將指定的元素添加到此列表的尾部。
public boolean add(E e) {
    // 增加modCount
    ensureCapacity(size + 1);
    elementData[size++] = e;
    return true;
}
// 將指定的元素插入此列表中的指定位置。
// 如果當前位置有元素，則向右移動位于該位置的元素及所有后續(xù)元素（其索引加1）。
public void add(int index, E element) {
    // if (index > size || index < 0)
    //    throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    rangeCheckForAdd(index);
    // 如果數(shù)組長度不足，將進行擴容。
    ensureCapacity(size + 1); // 增加modCount
    // 將 elementData中從Index位置開始、長度為size-index的元素，
    // 拷貝到從下標為index+1位置開始的新的elementData數(shù)組中。
    // 即將當前位于該位置的元素以及所有后續(xù)元素右移一個位置。
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}
// 按照指定collection的迭代器所返回的元素順序，將該collection中的所有元素添加到此列表的尾部。
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacity(size + numNew); // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}
// 從指定的位置開始，將指定collection中的所有元素插入到此列表中。
public boolean addAll(int index, Collection<? extends E> c) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacity(size + numNew); // 增加modCount
    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

// 刪除此列表中指定位置的元素。將任何后續(xù)元素向左移動（從它們的索引中減去一個）。    
public E remove(int index) {
   rangeCheck(index);
   modCount++;
   E oldValue = elementData(index);
   int numMoved = size - index - 1;
   if (numMoved > 0)
       System.arraycopy(elementData, index+1, elementData, index, numMoved);
   elementData[--size] = null; // clear to let GC do its work
   return oldValue;
}

// 從此列表中刪除第一次出現(xiàn)的指定元素（如果存在）。如果列表不包含該元素，則保持不變。 
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
// 私有刪除方法，跳過邊界檢查并且不返回刪除的值。
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; 
}

// 從此列表中刪除索引介于兩者之間的所有元素    
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
    System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) {
        elementData[i] = null;
    }
    size = newSize;
}

ArrayList<Integer> ints = new ArrayList<Integer>(Arrays.asList(0, 1, 2, 3, 4, 5, 6));
ints.subList(2, 4).clear();
System.out.println(ints);

public void ensureCapacity(int minCapacity) {
   modCount++;
   int oldCapacity = elementData.length;
   if (minCapacity > oldCapacity) {
       Object oldData[] = elementData;
       int newCapacity = (oldCapacity * 3) / 2 + 1; // 增加50%+1
       if (newCapacity < minCapacity)
           newCapacity = minCapacity;
       // 通常接近 size
       elementData = Arrays.copyOf(elementData, newCapacity);
   }
}

// 為什么要用到
oldData[]Object oldData[] = elementData;

// 將此ArrayList實例的容量修剪為列表的當前大小?？梢允褂么瞬僮鱽碜钚』疉rrayList實例的存儲空間。    
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

// 返回一個數(shù)組，該數(shù)組以適當?shù)捻樞虬肆斜碇械乃性亍?   
public Object[] toArray() {    return Arrays.copyOf(elementData, size);}

/* 以適當?shù)捻樞蚍祷匾粋€包含此列表中所有元素的數(shù)組；
返回數(shù)組的運行時類型是指定數(shù)組的類型。
如果列表適合指定的數(shù)組，則在其中返回。
否則將使用指定數(shù)組的運行時類型和此列表的大小分配一個新數(shù)組。*/     
public <T> T[] toArray(T[] a) {
   if (a.length < size)
       // 創(chuàng)建一個運行時類型的新數(shù)組
       return (T[]) Arrays.copyOf(elementData, size, a.getClass());
   System.arraycopy(elementData, 0, a, 0, size);
   if (a.length > size)
       a[size] = null;
   return a;
}

  public static <T> T[] copyOf(T[] original, int newLength) {   
    return (T[]) copyOf(original, newLength, original.getClass());
  }

// newType類
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {    
    @SuppressWarnings("unchecked")    
    T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength]: (T[]) 
    Array.newInstance(newType.getComponentType(), newLength);    
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));    
    return copy;
}