Java集合—ArrayList

ArrayList

ArrayList使用

• ArrayList是List接口的实现类
• 集合框架库
• Collection
• 常用方法 add addAll remove contain toArray
• List-定义允许重复的一个有序集合
• ArrayList - “动态”的数组

ArrayList基本特点

• 数据插入有序
• 可以存储null值
• 数据可以重复
• 底层基于数组实现，数组在内存中是连续分布的内存空间

ArrayList底层源码实现

• 类的继承关系

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

继承自AbstractList，对Collection接口中的部分方法做了实现
实现了List接口，List接口中的方法都需要在ArrayList中进行实现
实现了RandomAccess、Cloneable、java.io.Serializable可以实现克隆，可以实现序列化、反序列化

• 类的成员变量

    //默认初始化容量
    private static final int DEFAULT_CAPACITY = 10;
    //空对象数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //对象数组
    private transient Object[] elementData;
    //集合元素个数
    private int size;

• 类的构造函数

有参构造函数：表示执行初始数组容量

  public ArrayList(int initialCapacity) {
        //检查参数合法性
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //对属性elementData初始化
        this.elementData = new Object[initialCapacity];
    }

默认的无参构造函数：

 public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

• 主要方法分析

1. add()方法：添加元素

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
 private void ensureCapacityInternal(int minCapacity) {
           if (elementData == EMPTY_ELEMENTDATA) {
              //数组未做初始化时会进入该操作，获取初始容量：10
               minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
           }

           ensureExplicitCapacity(minCapacity);
   }
  private void ensureExplicitCapacity(int minCapacity) {
          modCount++;

          // overflow-conscious code
          if (minCapacity - elementData.length > 0)
              //考虑扩容
              grow(minCapacity);
  }

扩容时机：数组存储数据的个数（size+1）大于数组的长度，进行扩容

//扩容代码  扩容机制
  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);
  }

添加元素过程注意：
1.考虑扩容
当存储数据个数(size)大于数组长度(elementData.length)时,需要进行扩容
按照原数组的1.5倍进行扩容（新建数组，将原数据拷贝到新数组上，并使e lementData指向新数组）
2.数据插入到最后的位置(size)
3.对计数器size进行加1

2.get(int index)方法：获取元素

public E get(int index) {
        rangeCheck(index);

        return elementData(index);
 }
 //检查参数是否合法
private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

E elementData(int index) {
    return (E) elementData[index];
}

获取元素过程注意：检查参数是否合法
3.remove()方法：删除元素

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

删除元素过程注意：
从数组0号位置往后遍历，判断是否是否存在重复（null值使用==，非null值使用equals判断相等）
存在则直接删除第一次出现的数据，将该位置后续所有数据前移一位，最后一位数据置为null