java基础，集合，Arraylist，源码解析(基础)

ArrayList

• 是什么，定义？

这是动态的数组，它提供了动态的增加和减少元素，实现了List接口（List实现Collection，所以也实现Collection接口）灵活的设置数组的大小等好处

　　

• 内部如何实现

     /**
      * 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;//定义大小

     /**
      * Constructs an empty list with the specified initial capacity.
      *
      * @param  initialCapacity  the initial capacity of the list
      * @throws IllegalArgumentException if the specified initial capacity
      *         is negative
      */
     public ArrayList(int initialCapacity) {//带参数的初始化
         super();
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Illegal Capacity: "+
                                                initialCapacity);
         this.elementData = new Object[initialCapacity];
     }

     /**
      * Constructs an empty list with an initial capacity of ten.
      */
     public ArrayList() {//默认初始化，大小是10
         this(10);
     }

• 添加如何操作

   public boolean add(E e) {
         ensureCapacityInternal(size + 1);  // 进行长度的判断与修改（将检查与扩容放在一个方法调用，代码阅读性高）
         elementData[size++] = e;
         return true;
     }
 　　
     private void ensureCapacityInternal(int minCapacity) {
         modCount++;
         // overflow-conscious code
         if (minCapacity - elementData.length > 0)//进行判断
             grow(minCapacity);
     }

     private void grow(int minCapacity) {
         // overflow-conscious code
         int oldCapacity = elementData.length;
         int newCapacity = oldCapacity + (oldCapacity >> 1);//扩大原来的二分之一
         if (newCapacity - minCapacity < 0)//最小的长度
             newCapacity = minCapacity;
         if (newCapacity - MAX_ARRAY_SIZE > 0)//最大长度
             newCapacity = hugeCapacity(minCapacity);
         // minCapacity is usually close to size, so this is a win:
         elementData = Arrays.copyOf(elementData, newCapacity);
     }

• 添加重要的一部，扩容，——这是为什么实际应用中要定义数组大小的原因，

    //Array的源代码
 public static <T> T[] copyOf(T[] original, int newLength) {
         return (T[]) copyOf(original, newLength, original.getClass());
     }

     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;
     }

• 制定位置的添加

     public void add(int index, E element) {
         rangeCheckForAdd(index);

         ensureCapacityInternal(size + 1);  // Increments modCount!!
         System.arraycopy(elementData, index, elementData, index + 1,
                          size - index);//仅仅是当前位置以后的对象进行复制
         elementData[index] = element;
         size++;
     }

• 删除对象

    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; // Let gc do its work

        return oldValue;
    }

• 怎么遍历呢？

数组，通过数组的脚标，遍历；

for each 因为实现Iterator，也可以使用迭代器

　　

使用中改注意：

1、初始化最好定义都用的长度，避免Arrarlist内部复制的操作；

2、如果删除的，尽量从后往前删除

3、不是线程安全，全部代码中都没有synchronized ，

　　如果有需要，使用Vector，两者的区别3点（其他基本是一样）：

　　线程安全，

　　多了方法indexOf，

　　扩容的打大小是：1倍

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