• 知识脉络
      • arraylist底层是一个object的数组，优点是随机访问快，缺点是扩容和插入和删除元素，会进行元素拷贝性能查，不是线程安全
      • 创建Arraylist，不指定大小，arraylist第一次添加元素，会指定默认的容量大小为10
      • ArrayList的扩容机制主要有两点，一个是计算扩容的大小=原值+原值右移1（等价1.5倍），一个是底层通过System.arrycopy来拷贝元素和创建信数组，来最终实现空间的扩容
      • 核心方法大多通过system.arraycopy进行拷贝元素做到的，removelf方法中
      • 遍历通过内部类ltr遍历时会向后访问，Listltr遍历向前、向后均可访问，由于不是线程安全，通过modcout的检测，实现fail-fast机制
      • Vector通过synchronized关键字的ArrayList，线程安全，扩容是原来的2倍，stack继承了vector，使用数组模仿栈的操作而已
      • fail-fast 机制，即快速失败机制，是java集合(Collection)中的一种错误检测机制。当使用迭代器时候，进行一定的改变，就有可能会发生fail-fast，即抛出ConcurrentModificationException异常。fail-fast机制并不保证在不同步的修改下一定会抛出异常，它只是尽最大努力去抛出，所以这种机制通常用来检测bug，在迭代删除值的时候，要使用iterator,remove()方法，通过checkForComodification方法来检查modCount 和expectedModCount，如果不一致则会报出concurrentmodifictionException，在高并发环境下，推荐使用CopyOnWriteArrayList,ConcurrentHashMap
    • 扩容源码：
    • 内部类
      • ArrayListSpliterator （分离器）
        1.     Spliterator是jdk8新引入的，它与collection，stream api结合使用，可以并发处理数据，默认进行是进行二次分割，也可以进行自定义重写相关方法，
    1.  private int index; //当前位置
    2.  private int fence; //结束位置
    3.  private int expectedModCount; //modecount
    5. //获取当前的位置
    6. private int getFence() {
    7.             int hi;
    8.             if ((hi = this.fence) < 0) { //防止负数出现，已经运行完毕
    9.                 this.expectedModCount = ArrayList.this.modCount;
    10.                 hi = this.fence = ArrayList.this.size; 
    11.             }
    12.             return hi;
    13.         }
    14. //尝试切割
    15.   public ArrayList<E>.ArrayListSpliterator trySplit() {
    16.             int hi = this.getFence();
    17.             int lo = this.index;
    18.             int mid = lo + hi >>> 1; 右运算符1，计算出中间的位置
    19.             return lo >= mid ? null : ArrayList.this.new ArrayListSpliterator(lo, this.index = mid, this.expectedModCount);
    20.         }
    21.     //单次遍历，改变index只加1
    22.   public boolean tryAdvance(Consumer<? super E> action) {
    23.             if (action == null) {
    24.                 throw new NullPointerException();
    25.             } else {
    26.                 int hi = this.getFence();
    27.                 int i = this.index;
    28.                 if (i < hi) {
    29.                     this.index = i + 1;
    30.                     E e = ArrayList.this.elementData[i];
    31.                     action.accept(e);
    32.                     if (ArrayList.this.modCount != this.expectedModCount) {
    33.                         throw new ConcurrentModificationException();
    34.                     } else {
    35.                         return true;
    36.                     }
    37.                 } else {
    38.                     return false;
    39.                 }
    40.             }
    41.         }
    43.     //整体遍历
    44.    public void forEachRemaining(Consumer<? super E> action) {
    45.             if (action == null) {
    46.                 throw new NullPointerException();
    47.             } else {
    48.                 Object[] a;
    49.                 if ((a = ArrayList.this.elementData) != null) {
    50.                     int hi;
    51.                     int mc;
    52.                     if ((hi = this.fence) < 0) {
    53.                         mc = ArrayList.this.modCount;
    54.                         hi = ArrayList.this.size;
    55.                     } else {
    56.                         mc = this.expectedModCount;
    57.                     }
    58.                     int i;
    59.                     if ((i = this.index) >= 0 && (this.index = hi) <= a.length) {
    60.                         while(i < hi) {
    61.                             E e = a[i];
    62.                             action.accept(e);
    63.                             ++i;
    64.                         }
    66.                         if (ArrayList.this.modCount == mc) {
    67.                             return;
    68.                         }
    69.                     }
    70.                 }
    71.                 throw new ConcurrentModificationException();
    72.             }
    73.         }
    • SubList
      1.     arrayList.sublist返回的是父集合的一部分视图，是视图、是视图、是视图，重要的事说3遍，无论改变那个集合，另一个都会随动。
    1.  public List<E> subList(int fromIndex, int toIndex) {
    2.         subListRangeCheck(fromIndex, toIndex, this.size);
    3.         return new ArrayList.SubList(this, fromIndex, toIndex);//生成一个子类SubList
    4.     }
    5.       //set,get,size,add,remove 都会检测modcount，fast-fail机制
    6.       private void checkForComodification() {
    7.             if (this.root.modCount != this.modCount) {
    8.                 throw new ConcurrentModificationException();
    9.             }
    10.         } 
    12.         public E set(int index, E element) {
    13.             Objects.checkIndex(index, this.size);
    14.             this.checkForComodification();
    15.             E oldValue = this.root.elementData(this.offset + index);
    16.             this.root.elementData[this.offset + index] = element;
    17.             return oldValue;
    18.         }
    20.         public E get(int index) {
    21.             Objects.checkIndex(index, this.size);
    22.             this.checkForComodification();
    23.             return this.root.elementData(this.offset + index);
    24.         }
    26.         public int size() {
    27.             this.checkForComodification();
    28.             return this.size;
    29.         }
    31.         public void add(int index, E element) {
    32.             this.rangeCheckForAdd(index);
    33.             this.checkForComodification();
    34.             this.root.add(this.offset + index, element);
    35.             this.updateSizeAndModCount(1);
    36.         }
    38.         public E remove(int index) {
    39.             Objects.checkIndex(index, this.size);
    40.             this.checkForComodification();
    41.             E result = this.root.remove(this.offset + index);
    42.             this.updateSizeAndModCount(-1);
    43.             return result;
    44.         }
    • ltr
      1.    arrylist.iterator 触发内部类ltr
    1.     public Iterator<E> iterator() {
    2.         return new ArrayList.Itr();
    3.     }
    • listltr
    1. public ListIterator<E> listIterator(int index) {
    2.         this.rangeCheckForAdd(index);
    3.         return new ArrayList.ListItr(index);
    4.     }
    6.     public ListIterator<E> listIterator() {
    7.         return new ArrayList.ListItr(0);
    8.     }