LinkedList for 和 forEach遍历分析

 

Java中LinkenList数据结构->链表

 

链式存储，Sequential Access：

　　这种方式，每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含他的下一个元素的内存地址，不可以根据元素的位置直接计算出内存地址，只能按照顺序读取元素。主要是以链表为代表。

 

1.传统的for循环遍历，基于计数器的：

遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到一最后一个元素后停止。主要是需要按元素的位置来读取。这也是最原始的集合遍历方法。 

LinkedList链表，对于链式存储(size=n)读取一个特定位置元素的平均时间复杂度约为O(n/4),遍历整个集合的平均时间复杂度约为O(n^2/4) ,即四分之一n的平方)

代码实现：

 

public static void forTest(List<String> list){

    int size = list.size();

    for(int i=0;i<size;i++) {

        String v =  list.get(0);

    }

}

源码分析：new LinkenList().get()

数据结构：Node链表

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

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

 

从代码分析 new LinkenList().get() 当 index < size/2 时 向下一节点遍历，

遍历平局次数 （1+size /2）/2;当 index > size/2 时 倒叙向上一节点遍历，

遍历平局次数 （1+size/2）/2;

总次数约为  size/2+size^2/4 约 n^2/4

 

2.foreach 循环遍历：

内部也是采用了Iterator的方式实现，LinkenList extends AbstractSequentialList extends AbstractList 重写了 iterator() 方法

代码实现：

public static void forEach(List<String> list){

    for(String str : list){

       String v = str;

    }

}

源码解析:forEach 实现是调用LinkenList extends AbstractSequentialList 的 iterator() 方法, 在通过调用 AbstractSequentialList extends AbstractList 的 listIterator() 方法,最后在listIterator(0)方法new ListItr().next() 遍历对象


1.AbstractSequentialList.calss

public Iterator<E> iterator() {
    return listIterator();
}

 

2.AbstractList.class

 

public ListIterator<E> listIterator() {
    return listIterator(0);
}

 

3.LinkedList.calss

 

public ListIterator<E> listIterator(int index) {
    checkPositionIndex(index);
    return new ListItr(index);
}

private class ListItr implements ListIterator<E> {
    private Node<E> lastReturned;
    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;
    }

    public boolean hasPrevious() {
        return nextIndex > 0;
    }

   //。。。代码省略。。。
}

 

从代码分析 LinkenList forEach遍历 是通过Iterator迭代器，向下一节点遍历对象，整体的时间复杂度约o(n)

 

LinkenList for、forEach 遍历测试结果如下：（测试结果仅供参考）

分析结果：LinkedList集合遍历的次数越多，forEach性能约是for性能 4.5倍

总结：对于LinkendList遍历建议使用forEach遍历，for遍历耗时在于读取特定元素循环遍历对象