先介绍几种初始化方法

// 带初始化容量的初始化    public ArrayList(int initialCapacity) {        if (initialCapacity > 0) {            // 初始话一个object 数组            this.elementData = new Object[initialCapacity];        } else if (initialCapacity == 0) {            // 初始话一个空数组            this.elementData = EMPTY_ELEMENTDATA;        } else {            // 抛出错误            throw new IllegalArgumentException("Illegal Capacity: "+                    initialCapacity);        }    }    // 默认初始化    public ArrayList() {        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    }    // 使用一个集合初始化    public ArrayList(Collection
      c) {        // 将集合转化成数组        elementData = c.toArray();        // size是arraylist的长度，赋予集合的长度        if ((size = elementData.length) != 0) {            // 长度不为0, 集合转化为数组后，如果类型不是object的，转为object            if (elementData.getClass() != Object[].class)                elementData = Arrays.copyOf(elementData, size, Object[].class);        } else {            // 初始化一个空数组            this.elementData = EMPTY_ELEMENTDATA;        }    }

重点看下c.toArray方法，假如这个集合是个arraylist类型的，那它的toArray实现如下

public Object[] toArray() {        return Arrays.copyOf(elementData, size);    }

发现，调用的是Arrays.copyof方法

public static 
     
       T[] copyOf(T[] original, int newLength) {        return (T[]) copyOf(original, newLength, original.getClass());    }
     

继续看

/**     *     * @param original 要复制的数组     * @param newLength 要复制的长度     * @param newType 要复制的数组的class类型     * @param 
     
           * @param 
           * @return     */    public static 
       
         T[] copyOf(U[] original, int newLength, Class
         newType) {        @SuppressWarnings("unchecked")        // 这步的作用其实是个优化，假如newType类型是一个object类型，那就直接使用new Object来进行创建数组，加入不是，就用反射的机制创建数组 　　　　　// 优化的理由应该是：反射创建数组的性能为比直接创建的性能来的低        // (Object)newType == (Object)Object[].class 这句话就是判断newType是不是一个object类型        // newType.getComponentType() 其实是获得数组类型，假如说数组是一个String[]，那这可以拿到String        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;    }
       
     

 再介绍ArrayList两个操作

// 移除所有在c集合里的元素    public boolean removeAll(Collection
      c) {        Objects.requireNonNull(c);        return batchRemove(c, false);    }    // 保留所有在c集合里的元素    public boolean retainAll(Collection
      c) {        Objects.requireNonNull(c);        return batchRemove(c, true);    }    //     private boolean batchRemove(Collection
      c, boolean complement) {        final Object[] elementData = this.elementData;        int r = 0, w = 0;        boolean modified = false;        try {            // 根据complement判断是否保留            for (; r < size; r++)                if (c.contains(elementData[r]) == complement)                    elementData[w++] = elementData[r];        } finally {            // Preserve behavioral compatibility with AbstractCollection,            // even if c.contains() throws.            // 假如出现错误,将这个元素后面的所有元素都放到elementData中，不在做去除操作            if (r != size) {                System.arraycopy(elementData, r,                        elementData, w,                        size - r);                w += size - r;            }            // 如果没出现错误            if (w != size) {                // clear to let GC do its work                // 将被去除的元素置为null                for (int i = w; i < size; i++)                    elementData[i] = null;                // 修改次数                modCount += size - w;                // 修改当前数组长度                size = w;                // 表示做过修改                modified = true;            }        }        return modified;    }

 提下java的迭代器，通过迭代器来操作ArrayList

取得迭代器

// 返回带指定游标的迭代器ListIterator    public ListIterator
     
       listIterator(int index) {        if (index < 0 || index > size)            throw new IndexOutOfBoundsException("Index: "+index);        return new ListItr(index);    }    // 返回游标默认为0的迭代器ListIterator    public ListIterator
      
        listIterator() {        return new ListItr(0);    }    // 返回默认的迭代器Iterator    public Iterator
       
         iterator() {        return new Itr();    }
       
      
     

再看下迭代器的实现

Iterator:

private class Itr implements Iterator
     
       {        int cursor;       // 角标，下个元素的位置        int lastRet = -1; // 上次操作的元素位置        int expectedModCount = modCount; //用户操作ArrayList，会改变modCount        public boolean hasNext() {            return cursor != size; // 角标不为ArrayList长度，则表示有下一个        }        @SuppressWarnings("unchecked")        public E next() {            checkForComodification(); // 检查用户是否在操作ArrayList，如果操作不在迭代            int i = cursor;            if (i >= size)                throw new NoSuchElementException();            Object[] elementData = ArrayList.this.elementData;            if (i >= elementData.length)                throw new ConcurrentModificationException();            cursor = i + 1; // 角标位置+1            return (E) elementData[lastRet = i]; // 返回当前元素        }        public void remove() {            if (lastRet < 0)                throw new IllegalStateException();            checkForComodification(); // 检查用户是否在操作ArrayList，如果操作不在迭代            try {                ArrayList.this.remove(lastRet); // ArrayList移除这个元素                cursor = lastRet;                lastRet = -1;                expectedModCount = modCount; // 重新赋予新的修改次数            } catch (IndexOutOfBoundsException ex) {                throw new ConcurrentModificationException();            }        }        // 从当前角标的位置，到结束，consumer为函数编程接口，传各个元素进去执行自定义函数，若在操作过程中，ArrayList发送了修改，则退出迭代，并抛出错误        @Override        @SuppressWarnings("unchecked")        public void forEachRemaining(Consumer
       consumer) {            Objects.requireNonNull(consumer);            final int size = ArrayList.this.size;            int i = cursor;            if (i >= size) {                return;            }            final Object[] elementData = ArrayList.this.elementData;            if (i >= elementData.length) {                throw new ConcurrentModificationException();            }            while (i != size && modCount == expectedModCount) {                consumer.accept((E) elementData[i++]);            }            // update once at end of iteration to reduce heap write traffic            cursor = i;            lastRet = i - 1;            checkForComodification();        }        // 检查当前的ArrayList是否被修改        final void checkForComodification() {            if (modCount != expectedModCount)                throw new ConcurrentModificationException();        }    }
     

listItr

private class ListItr extends Itr implements ListIterator
     
       {        // 角标设为index        ListItr(int index) {            super();            cursor = index;        }        // 判断前面是否有元素        public boolean hasPrevious() {            return cursor != 0;        }        // 返回当前角标，就是下个元素的位置        public int nextIndex() {            return cursor;        }        // 返回当前元素的位置        public int previousIndex() {            return cursor - 1;        }        // 返回当前元素,并将角标改为当前元素的位置        @SuppressWarnings("unchecked")        public E previous() {            checkForComodification();            int i = cursor - 1;            if (i < 0)                throw new NoSuchElementException();            Object[] elementData = ArrayList.this.elementData;            if (i >= elementData.length)                throw new ConcurrentModificationException();            cursor = i;            return (E) elementData[lastRet = i];        }        // 设置当前元素的值        public void set(E e) {            if (lastRet < 0)                throw new IllegalStateException();            checkForComodification();            try {                ArrayList.this.set(lastRet, e);            } catch (IndexOutOfBoundsException ex) {                throw new ConcurrentModificationException();            }        }        // 将值添加到当前元素之后        public void add(E e) {            checkForComodification();            try {                int i = cursor;                ArrayList.this.add(i, e);                cursor = i + 1;                lastRet = -1;                expectedModCount = modCount;            } catch (IndexOutOfBoundsException ex) {                throw new ConcurrentModificationException();            }        }    }
     

可以看出迭代器在遍历数组时，同时可以增加删除，角标都会随之发生变化。

而如果用for循环遍历ArrayList进行添加删除操作，如果不对当前位置进行一些控制，将发生一些明显的错误。在多线程的情况，操作ArrayList，你将无法知晓其它线程是否有进行添加删除操作，两方同时操作必将发生错误。

我们可以看看下面的add操作，它只是做了添加一个元素，并将size+1，而迭代器在添加的时候会进行判断modcount是否发生改变，并将角标自动+1。保证了操作的正确性。

// 添加 元素    public boolean add(E e) {        // 调整容量        ensureCapacityInternal(size + 1);  // Increments modCount!!        // 赋值，并将szie+1        elementData[size++] = e;        return true;    }    private void ensureCapacityInternal(int minCapacity) {        // 记得前面默认初始化ArrayList的时候，会将elementData赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {            // 这时候判断当前的size和DEFAULT_CAPACITY，第一次添加，size为0，所以容量将被初始化为常量10            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) { // 修改次数+1，如果迭代器这时候再操作元素，将抛出异常，并中断迭代 modCount++; // 如果minCapacity的容量大于数组中元素的长度 if (minCapacity - elementData.length > 0) grow(minCapacity); } private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; //newCapacity为元素长度的1.5倍 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); }

 

ArrayList中还有个可分割的迭代器

//可分割迭代器    static final class ArrayListSpliterator
     
       implements Spliterator
      
        {        //用于存放ArrayList对象        private final ArrayList
       
         list;        //起始位置（包含），advance/split操作时会修改        private int index;        //结束位置（不包含），-1 表示到最后一个元素        private int fence;        //用于存放list的modCount        private int expectedModCount;        ArrayListSpliterator(ArrayList
        
          list, int origin, int fence,                             int expectedModCount) {            this.list = list;            this.index = origin;            this.fence = fence;            this.expectedModCount = expectedModCount;        }        //获取结束位置（存在意义：首次初始化石需对fence和expectedModCount进行赋值）        private int getFence() {            int hi;            ArrayList
         
           lst;            //fence<0时（第一次初始化时，fence才会小于0）：            if ((hi = fence) < 0) {                //list 为 null时，fence=0                if ((lst = list) == null)                    hi = fence = 0;                else {                    //否则，fence = list的长度。                    expectedModCount = lst.modCount;                    hi = fence = lst.size;                }            }            return hi;        }        //分割list，返回一个新分割出的spliterator实例        // 这里要注意，index已被赋值为mid，起始位置已发生改变        public ArrayListSpliterator
          
            trySplit() { //hi为当前的结束位置 //lo 为起始位置 //计算中间的位置 int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; //当lo>=mid,表示不能在分割，返回null //当lo
           
            = mid) ? null : new ArrayListSpliterator
            
             (list, lo, index = mid, expectedModCount); } //返回true 时，只表示可能还有元素未处理 //返回false 时，没有剩余元素处理了。。。 // 注意index+1,角标向前移动了以为，下次再调用这个方法就是处理下个元素 public boolean tryAdvance(Consumer
              action) { if (action == null) throw new NullPointerException(); //hi为当前的结束位置 //i 为起始位置 int hi = getFence(), i = index; //还有剩余元素未处理时 if (i < hi) { //处理i位置，index+1 index = i + 1; @SuppressWarnings("unchecked") E e = (E)list.elementData[i]; action.accept(e); //遍历时，结构发生变更，抛错 if (list.modCount != expectedModCount) throw new ConcurrentModificationException(); return true; } return false; } //顺序遍历处理所有剩下的元素 //在这个方法里，角标index不发生变化，并处理index到fence里的元素 public void forEachRemaining(Consumer
              action) { int i, hi, mc; // hoist accesses and checks from loop ArrayList
             
               lst; Object[] a; if (action == null) throw new NullPointerException(); if ((lst = list) != null && (a = lst.elementData) != null) { //当fence<0时，表示fence和expectedModCount未初始化 if ((hi = fence) < 0) { /// 注意hi在这里被赋值 mc = lst.modCount; hi = lst.size; } else mc = expectedModCount; if ((i = index) >= 0 && (index = hi) <= a.length) { for (; i < hi; ++i) { @SuppressWarnings("unchecked") E e = (E) a[i]; //调用action.accept处理元素 action.accept(e); } //遍历时发生结构变更时抛出异常 if (lst.modCount == mc) return; } } throw new ConcurrentModificationException(); } // 返回剩下元素长度 public long estimateSize() { return (long) (getFence() - index); } public int characteristics() { //打上特征值：、可以返回size return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED; } }
             
            
           
          
         
        
       
      
     

 使用下这个ArrayList的可分割迭代器

public static void main(String[] args) throws IOException, ClassNotFoundException {        List
     
        arrs = new ArrayList<>();        arrs.add("a");        arrs.add("b");        arrs.add("c");        arrs.add("d");        arrs.add("e");        arrs.add("f");        arrs.add("h");        arrs.add("i");        arrs.add("j");        Spliterator
      
        a =  arrs.spliterator();        //运行到这里，结果：a:0-9（index-fence）        Spliterator
       
         b = a.trySplit();        //运行到这里，结果：a:4-9 b:0-4        Spliterator
        
          c = a.trySplit();        //运行到这里，结果：a:6-9 b:0-4 c:4-6    }
        
       
      
     

注意，这个分割都是从index到fence，fence一般为迭代器里最大操作位置，index为当前操作的位置，如果操作了第一个元素，比如使用了tryAdvance。那index+1，则分割的时候，也是index到(index+fence)/2;分割出去。

public static void main(String[] args) throws IOException, ClassNotFoundException {        List
     
        arrs = new ArrayList<>();        arrs.add("a");        arrs.add("b");        arrs.add("c");        arrs.add("d");        arrs.add("e");        arrs.add("f");        arrs.add("h");        arrs.add("i");        arrs.add("j");        Spliterator
      
        a =  arrs.spliterator();        //运行到这里，结果：a:0-9（index-fence）        Consumer
       
         t = (inputStr) -> {System.out.println(inputStr.equals("a") ? "的确为a":"不是a啊");};        a.tryAdvance(t);        //运行到这里，输出：的确为a        Spliterator
        
          b = a.trySplit();        //运行到这里，结果：a:5-9 b:1-5        Spliterator
         
           c = a.trySplit();        //运行到这里，结果：a:7-9 b:1-5 c:5-7    }