Java集合之ArrayList ？

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer.
 */
private transient Object[] elementData;   /**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
*/
private int size;

/**
* 构造一个初始容量为 10 的空列表 */public ArrayList() {    this(10);
}/**
* 构造一个具有指定初始容量的空列表。 */public ArrayList(int initialCapacity) {    super();    if (initialCapacity < 0)        throw new IllegalArgumentException("Illegal Capacity: "
+ initialCapacity);    this.elementData = new Object[initialCapacity];
}/**
*  构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。 */public ArrayList(Collection<? extends E> c) {
   elementData = c.toArray();
   size = elementData.length;    // c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
       elementData = Arrays.copyOf(elementData, size, Object[].class);
}

public static void main(String[] args)
{
   List<String> list = new ArrayList<String>();
   list.add("000");
   list.add("111");
}

1 public boolean add(E e) {2     ensureCapacity(size + 1);  // Increments modCount!!3     elementData[size++] = e;4     return true;5 }

public ArrayList() {     this(10);
}

public void ensureCapacity(int minCapacity) {
   modCount++;    int oldCapacity = elementData.length;    if (minCapacity > oldCapacity) {
       Object oldData[] = elementData;        int newCapacity = (oldCapacity * 3)/2 + 1;            if (newCapacity < minCapacity)
       newCapacity = minCapacity;               // minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
   }
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
      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;
}

 1 public static void main(String[] args) 2 { 3     List<String> list = new ArrayList<String>(); 4     list.add("111"); 5     list.add("222"); 6     list.add("333"); 7     list.add("444"); 8     list.add("555"); 9     list.add("666");10     list.add("777");11     list.add("888");12     list.add(2, "000");13     System.out.println(list);14 }

[111, 222, 000, 333, 444, 555, 666, 777, 888]

// 将指定的元素插入此列表中的指定位置。  // 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引加1）。  public void add(int index, E element) {  
  if (index > size || index < 0)  
      throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);  
  // 如果数组长度不足，将进行扩容。  
ensureCapacity(size+1);  // Increments modCount!!  
  // 将 elementData中从Index位置开始、长度为size-index的元素，  
  // 拷贝到从下标为index+1位置开始的新的elementData数组中。  
  // 即将当前位于该位置的元素以及所有后续元素右移一个位置。  
System.arraycopy(elementData, index, elementData, index + 1, size - index);  
  elementData[index] = element;  
  size++;  
} 

int numMoved = size - index - 1;if (numMoved > 0)
   System.arraycopy(elementData, index+1, elementData, index,
            numMoved);
elementData[--size] = null; // Let gc do its work

public static void main(String[] args)
{
   List<String> list = new ArrayList<String>();
   list.add("111");
   list.add("222");
   list.add("333");
   list.add("444");
   list.add("555");
   list.add("666");
   list.add("777");
   list.add("888");
   list.remove("333");
}

List<String> synchronizedList = Collections.synchronizedList(list);
synchronizedList.add("aaa");
synchronizedList.add("bbb");for (int i = 0; i < synchronizedList.size(); i++)
{
   System.out.println(synchronizedList.get(i));
}

int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);