for foreach

for foreach

对ArrayList这样的可使用下标进行随机访问的数据结构，使用下标for访问，要比foreach的方式进行顺序访问，速度要快一些。
因为 arraylist 底层是由数组组成的，使用for循环，直接由索引获取对象，速度是很快的，使用foreach迭代器要向下一个一个的遍历，速度是稍微一点点的慢过for，使用的过程产生一个额外的对象Enumerator，而且每次访问需要更多的操作，降低性能。
由于Enumerator中，做了版本检查处理的工作，所以使用foreach是线程安全，而使用for则不是。 如果在使用foreach遍历对象的过程中，其他线程修改了List的内容，例如添加或者删除，就会出现不可知的错误，而使用foreach则能够正确抛出错误信息。

但是迭代器发光的地方并不在底层由数组构成的集合上，迭代器用在 底层由双向指针链表构成的linkedlist 上，效率大大高于for循环。
如 果使用for循环遍历 底层由双向指针链表构成的linkedlist的话，他会每次都从头遍历一次，知道获取你给定的下标，然后开始下一次遍历，越往后速度越慢。下标越大， 速度越慢。但是对于迭代器，他不是根据下标完成的遍历，每取得一个对象后，他会根据这个对象的尾部指针取得下一个对象的内存位置，直接从内存位置取出内 容，这一点是for循环所不及的。

详细的比较和分析
http://www.trinea.cn/android/arraylist-linkedlist-loop-performance/

ArrayList

迭代器Itr – foreach

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }
    ……
}

下标get() – for

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

    return elementData(index);
}

从中可以看出get和Iterator的next函数同样通过直接定位数据获取元素，只是多了几个判断而已。

LinkedList

迭代器ListItr – foreach

private class ListItr implements ListIterator<E> {
    private Node<E> lastReturned = null;
    private Node<E> next;
    private int nextIndex;
    private int expectedModCount = modCount;

    ListItr(int index) {
        // assert isPositionIndex(index);
        next = (index == size) ? null : node(index);
        nextIndex = index;
    }

    public boolean hasNext() {
        return nextIndex < size;
    }

    public E next() {
        checkForComodification();
        if (!hasNext())
            throw new NoSuchElementException();

        lastReturned = next;
        next = next.next;
        nextIndex++;
        return lastReturned.item;
    }
    ……
}

直接get() – for

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

/**
 * Returns the (non-null) Node at the specified element index.
 */
Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

从上面代码中可以看出LinkedList迭代器的next函数只是通过next指针快速得到下一个元素并返回。而get方法会从头遍历直到index下标，查找一个元素时间复杂度为哦O(n)，遍历的时间复杂度就达到了O(n2)。
所以对于LinkedList的遍历推荐使用foreach，避免使用get方式遍历。

结果对比分析

ArrayList和LinkedList遍历方式结果对比分析
从上面的数量级来看，同样是foreach循环遍历，ArrayList和LinkedList时间差不多，可将本例稍作修改加大list size会发现两者基本在一个数量级上。
但ArrayList get函数直接定位获取的方式时间复杂度为O(1)，而LinkedList的get函数时间复杂度为O(n)。
再结合考虑空间消耗的话，建议首选ArrayList。对于个别插入删除非常多的可以使用LinkedList。

结论总结

通过上面的分析我们基本可以总结下：
(1) 无论ArrayList还是LinkedList，遍历建议使用foreach，尤其是数据量较大时LinkedList避免使用get遍历。
(2) List使用首选ArrayList。对于个别插入删除非常多的可以使用LinkedList。
(3) 可能在遍历List循环内部需要使用到下标，这时综合考虑下是使用foreach和自增count还是get方式。