ArrayList的注意事项

  1. 1）permits all elements,including null,ArrayList可以加入null值，并且可以加入多个
  2. 2）ArrayList是由数组来实现数据存储的
  3. 3）ArrayList基本等同于Vector，除了ArrayList是线程不安全（执行效率高）看源码，
  4.      在多线程情况下，不建议使用ArrayList

ArrayList底层结构和源码分析

ArrayList的底层操作机制源码分析（重点、难点）

  1. 1）ArrayList中维护了一个Object类型的数组elementData.[debug看源码]
  2.    transient Object[] elementData;  // 表示瞬间的，短暂的，表示该属性不会被序列化
  3. 2）当创建ArrayList对象时，如果使用的是无参构造，则初始elementData容量为0，
  4.      第一次添加，则扩容elementData为10，如果需要再次扩容，则扩容elementData为1.5倍。   
  5. 3）如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，
  6.      则直接扩容elementData为1.5倍。

ArrayList源码分析

  1. // 1.创建一个空的elementData数组{}
  2.     public ArrayList() {
  3.       super();
  4.       this.elementData = EMPTY_ELEMENTDATA;
  5.     }
  7. // 2.执行list.add
  8.     public boolean add(E e) {
  9.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  10.         elementData[size++] = e;
  11.         return true;
  12.     }
  13.   // 先确定是否要扩容，然后再执行赋值
  15. // 3.该方法，确定minCapacity，第一次扩容为10
  16.     private void ensureCapacityInternal(int minCapacity) {
  17.         if (elementData == EMPTY_ELEMENTDATA) {
  18.             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
  19.         }
  21.         ensureExplicitCapacity(minCapacity);
  22.     }
  24. // 4.modCount++记录几何被修改的次数
  25. //     如果elementData的大小不够，就调用grow()扩容
  26.     private void ensureExplicitCapacity(int minCapacity) {
  27.         modCount++;
  29.         // overflow-conscious code
  30.         if (minCapacity - elementData.length > 0)
  31.             grow(minCapacity);
  32.     }
  34. /*
  35.     5.1 真的扩容
  36.   5.2 使用扩容机制来确定要扩容到多大
  37.   5.3 第一次newCapacity = 10
  38.   5.4 第二次及以后按照1.5倍扩容
  39.   5.5 扩容使用的是Arrays.copyOf()
  40. */
  41.     private void grow(int minCapacity) {
  42.         // overflow-conscious code
  43.         int oldCapacity = elementData.length;
  44.         int newCapacity = oldCapacity + (oldCapacity >> 1);
  45.         if (newCapacity - minCapacity < 0)
  46.             newCapacity = minCapacity;
  47.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  48.             newCapacity = hugeCapacity(minCapacity);
  49.         // minCapacity is usually close to size, so this is a win:
  50.         elementData = Arrays.copyOf(elementData, newCapacity);
  51.     }