public static void arraycopy(Object src,
             int srcPos, Object dest,
             int destPos,
             int length)

1. public boolean add(E e) {  
2.     ensureCapacityInternal(size + 1);  // Increments modCount!!  
3.     elementData[size++] = e;  
4.     return true;  
5. }  
6.   
7. private void ensureCapacityInternal(int minCapacity) {  
8.     if (elementData == EMPTY_ELEMENTDATA) {  
9.         minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);  
10.     }  
11.   
12.     ensureExplicitCapacity(minCapacity);  
13. }  
14.   
15. private void ensureExplicitCapacity(int minCapacity) {  
16.     modCount++;  
17.   
18.     // overflow-conscious code  
19.     if (minCapacity - elementData.length > 0)  
20.         grow(minCapacity);  
21. }  
22. private void grow(int minCapacity) {  
23.     // overflow-conscious code  
24.     int oldCapacity = elementData.length;  
25.     int newCapacity = oldCapacity + (oldCapacity >> 1);  
26.     if (newCapacity - minCapacity < 0)  
27.         newCapacity = minCapacity;  
28.     if (newCapacity - MAX_ARRAY_SIZE > 0)  
29.         newCapacity = hugeCapacity(minCapacity);  
30.     // minCapacity is usually close to size, so this is a win:  
31.     elementData = Arrays.copyOf(elementData, newCapacity);  
32. }  

1. public void add(int index, E element) {  
2.     rangeCheckForAdd(index);  
3.   
4.     ensureCapacityInternal(size + 1);  // Increments modCount!!  
5.     System.arraycopy(elementData, index, elementData, index + 1,  
6.                      size - index);  
7.     elementData[index] = element;  
8.     size++;  
9. }  
10. 
    
11. public E remove(int index) {  
12.     rangeCheck(index);  
13.   
14.     modCount++;  
15.     E oldValue = elementData(index);  
16.   
17.     int numMoved = size - index - 1;  
18.     if (numMoved > 0)  
19.         System.arraycopy(elementData, index+1, elementData, index,  
20.                          numMoved);  
21.     elementData[--size] = null; // clear to let GC do its work  
22.   
23.     return oldValue;  
24. }  
25. 
    
26. public boolean remove(Object o) {  
27.     if (o == null) {  
28.         for (int index = 0; index < size; index++)  
29.             if (elementData[index] == null) {  
30.                 fastRemove(index);  
31.                 return true;  
32.             }  
33.     } else {  
34.         for (int index = 0; index < size; index++)  
35.             if (o.equals(elementData[index])) {  
36.                 fastRemove(index);  
37.                 return true;  
38.             }  
39.     }  
40.     return false;  
41. }  
42. 
    
43. public boolean addAll(Collection<!--? extends E> c) {  
44.     Object[] a = c.toArray();  
45.     int numNew = a.length;  
46.     ensureCapacityInternal(size + numNew);  // Increments modCount  
47.     System.arraycopy(a, 0, elementData, size, numNew);  
48.     size += numNew;  
49.     return numNew != 0;  
50. }