《知识点020：Java中LinkedList遍历（7种）》_java 链表遍历

一、LinkedList类介绍

LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.，它和ArrayList一样实现了List接口，但是她执行插入和删除操作时比ArrayList更加高效，因为她是基于链表的，但同时也决定了她在随机访问方面要比ArrayList弱一点。

1.1：结构原理

LinkedList底层的数据结构是基于双向循环链表的，且头结点中不存放数据,如下：

既然是双向链表，那么必定存在一种数据结构——我们可以称之为节点，节点实例保存业务数据，前一个节点的位置信息和后一个节点位置信息，如下图所示：

 

1.2：构造方法

public LinkedList() {//生成空的链表
    header.next = header.previous = header;
}
public LinkedList(Collection<? extends E> c) {//复制构造函数
    this();
    addAll(c);
}

第一个构造方法不接受参数，将header实例的previous和next全部指向header实例（注意，这个是一个双向循环链表，如果不是循环链表，空链表的情况应该是header节点的前一节点和后一节点均为null），这样整个链表其实就只有header一个节点，用于表示一个空的链表。执行完构造函数后，header实例自身形成一个闭环，如下图所示：

第二个构造方法接收一个Collection参数c，调用第一个构造方法构造一个空的链表，之后通过addAll将c中的元素全部添加到链表中。

二、LinkedList遍历（7种）

2.1：一般的for循环(随机访问)遍历

int size = list.size();  
for (int i=0; i<size; i++) {  
    list.get(i);          
}

2.2：for--each循环遍历

for (Integer integ:list){
    ;
}

2.3：迭代器iterator遍历

for(Iterator iter = list.iterator(); iter.hasNext();)  
iter.next();

2.4：用pollFirst()遍历

while(list.pollFirst() != null)  
;

2.5：用pollLast()遍历

while(list.pollLast() != null)  
;

2.6：用removeFirst()遍历

try {  
    while(list.removeFirst() != null)  
    ;  
} catch (NoSuchElementException e) {  
}

2.7：用removeLast()遍历

try {  
    while(list.removeLast() != null)  
    ;  
} catch (NoSuchElementException e) {  
}

2.8：实例

public class LinkedListTest {  
    public static void main(String[] args) {  
        LinkedList<Integer> llist = new LinkedList<Integer>();  
        for (int i=0; i<100000; i++)  
        llist.addLast(i);  
 
        byCommonFor(llist) ;// 通过一般for循环来遍历LinkedList  
        byForEach(llist) ;  // 通过for-each来遍历LinkedList  
        byIterator(llist) ; // 通过Iterator来遍历LinkedList  
        byPollFirst(llist) ;    // 通过PollFirst()遍历LinkedList     
        byPollLast(llist) ; // 通过PollLast()遍历LinkedList   
        byRemoveFirst(llist) ;   // 通过removeFirst()遍历LinkedList     
        byRemoveLast(llist) ; // 通过removeLast()遍历LinkedList  
    }  
 
 
    private static void byCommonFor(LinkedList<Integer> list) {// 通过一般for循环来遍历LinkedList  
        if (list == null)  
            return ;  
        long start = System.currentTimeMillis();       
        int size = list.size();  
        for (int i=0; i<size; i++) {  
            list.get(i);          
        }  
        long end = System.currentTimeMillis();  
        long total = end - start;  
        System.out.println("byCommonFor------->" + total+" ms");  
    }  
 
    private static void byForEach(LinkedList<Integer> list) {// 通过for-each来遍历LinkedList  
        if (list == null)  
            return ;   
        long start = System.currentTimeMillis();         
        for (Integer integ:list)   
        ;   
        long end = System.currentTimeMillis();  
        long total = end - start;  
        System.out.println("byForEach------->" + total+" ms");  
    }  
 
    private static void byIterator(LinkedList<Integer> list) {// 通过Iterator来遍历LinkedList  
        if (list == null)  
            return ;   
        long start = System.currentTimeMillis();       
        for(Iterator iter = list.iterator(); iter.hasNext();)  
        iter.next();   
        long end = System.currentTimeMillis();  
        long total = end - start;  
        System.out.println("byIterator------->" + total+" ms");  
    }  
 
    private static void byPollFirst(LinkedList<Integer> list) {//通过PollFirst()遍历LinkedList     
        if (list == null)  
            return ;   
        long start = System.currentTimeMillis();  
        while(list.pollFirst() != null)  
        ;   
        long end = System.currentTimeMillis();  
        long total = end - start;  
        System.out.println("byPollFirst------->" + total+" ms");  
    }  
 
    private static void byPollLast(LinkedList<Integer> list) {// 通过PollLast()遍历LinkedList   
        if (list == null)  
            return ;   
        long start = System.currentTimeMillis();  
        while(list.pollLast() != null)  
        ;   
        long end = System.currentTimeMillis();  
        long total = end - start;  
        System.out.println("byPollLast------->" + total+" ms");  
    }  
 
    private static void byRemoveFirst(LinkedList<Integer> list) {// 通过removeFirst()遍历LinkedList  
        if (list == null)  
            return ;   
        long start = System.currentTimeMillis();  
        try {  
            while(list.removeFirst() != null)  
                ;  
        } catch (NoSuchElementException e) {  
        }   
        long end = System.currentTimeMillis();  
        long total = end - start;  
        System.out.println("byRemoveFirst------->" + total+" ms");  
    }  
   
    private static void byRemoveLast(LinkedList<Integer> list) {// 通过removeLast()遍历LinkedList  
        if (list == null)  
            return ;  
        long start = System.currentTimeMillis();  
        try {  
            while(list.removeLast() != null)  
                ;  
        } catch (NoSuchElementException e) {  
        }  
        long end = System.currentTimeMillis();  
        long total = end - start;  
        System.out.println("byRemoveLast------->" + total+" ms");  
    }  
}

运行结果：
由此可见，遍历LinkedList时，使用removeFist()或removeLast()效率最高。但用它们遍历时，会删除原始数据；若单纯只读取，而不删除，LinkedList遍历时建议使用For-each或者迭代器的方式。千万不要通过随机访问去遍历LinkedList！

byCommonFor------->5342 ms
byForEach------->11 ms
byIterator------->8 ms
byPollFirst------->4 ms
byPollLast------->0 ms
byRemoveFirst------->0 ms
byRemoveLast------->0 ms

---