《Java基础-集合：LinkedList类的介绍和使用（最全篇）》

（一）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中的元素全部添加到链表中。

1.3：私有属性

private transient Entry<E> header = new Entry<E>(null, null, null);
private transient int size = 0;

header是双向链表的头节点，它是双向链表节点所对应的类Entry的实例。Entry中包含成员变量： previous, next, element。其中，previous是该节点的上一个节点，next是该节点的下一个节点，element是该节点所包含的值。 size是双向链表中节点实例的个数。

1.4：方法

add(E e)：将指定元素添加到此列表的结尾
add(int index, E element)：在此列表中指定的位置插入指定的元素
addAll(Collection<? extends E> c)：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序
addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素从指定位置开始插入此列表
AddFirst(E e)：将指定元素插入此列表的开头
addLast(E e)：将指定元素添加到此列表的结尾
clear()：从此列表中移除所有元素
remove()：获取并移除此列表的头（第一个元素）
remove(int index)：移除此列表中指定位置处的元素
remove(Objec o)：从此列表中移除首次出现的指定元素（如果存在）。
removeFirst()：移除并返回此列表的第一个元素
removeFirstOccurrence(Object o)：从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）
removeLast()：移除并返回此列表的最后一个元素
removeLastOccurrence(Object o)：从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）
get(int index)：返回此列表中指定位置处的元素
getFirst()：返回此列表的第一个元素
getLast()：返回此列表的最后一个元素
indexOf(Object o)：返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1
lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1

1.5：Iterator遍历数据

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

在LinkedList中提供了获取ListItr对象的方法：listIterator(int index)，该方法只是简单的返回了一个ListItr对象。LinkedList中还有通过集成获得的listIterator()方法，该方法只是调用了listIterator(int index)并且传入0。

public Iterator<E> descendingIterator() {
    return new DescendingIterator();
}

LinkedList还有一个提供Iterator的方法：descendingIterator()。该方法返回一个DescendingIterator对象。DescendingIterator是LinkedList的一个内部类。

1.6：使用案例

public static void main(String[] args) {
    List < String > a = new LinkedList < >();
    a.add("Amy");
    a.add("Carl");
    a.add("Erica");

    List < String > b = new LinkedList < >();
    b.add("Bob");
    b.add("Doug");
    b.add("Frances");
    b.add("Gloria");

    ListIterator < String > aIter = a.listIterator();
    Iterator < String > bIter = b.iterator();

    while (bIter.hasNext()) {
        if (aIter.hasNext()) aIter.next();
        aIter.add(bIter.next());
    }
    System.out.println(a);

    bIter = b.iterator();
    while (bIter.hasNext()) {
        bIter.next();
        if (bIter.hasNext()) {
            bIter.next();
            bIter.remove();
        }
    }
    System.out.println(b);

    a.removeAll(b);

    System.out.println(a);
}

 

（二）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

---

 

（三）LinkedList排序（2种）

LinkedList通过Collections.sort进行排序，代码如下：

3.1：降序

public class Person1 implements Comparable < Person1 > {
    private Float height;
    private String name;

    Person1(float height) {
        this.height = height;
    }

    public Float getHeight() {
        return height;
    }

    public void setHeight(float height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override public int compareTo(Person1 p) {
        if (this.getHeight() < p.getHeight()) {
            return 1;

        } else if (this.getHeight() > p.getHeight()) {
            return - 1;
        } else {
            return 0;
        }
    }
}

public class Question3_1 {

    public static void main(String[] args) {
        Person1 p1 = new Person1(23.4f);
        p1.setName("Stud1");
        Person1 p2 = new Person1(2.34f);
        p2.setName("Stud2");
        Person1 p3 = new Person1(34.32f);
        p3.setName("Stud3");
        Person1 p4 = new Person1(56.45f);
        p4.setName("Stud4");
        Person1 p5 = new Person1(21.4f);
        p5.setName("Stud5");

        LinkedList < Person1 > al = new LinkedList < Person1 > ();

        al.add(p1);
        al.add(p2);
        al.add(p3);
        al.add(p4);
        al.add(p5);

        Collections.sort(al); //这里控制降序
        for (Person1 p: al) System.out.println(p.getName() + " " + p.getHeight());
    }
}

运行结果：

Stud4 56.45
Stud3 34.32
Stud1 23.4
Stud5 21.4
Stud2 2.34

3.2：升序

修改上面代码 Collections.sort(al,Collections.reverseOrder());//更改为升序

运行结果：
Stud2 2.34
Stud5 21.4
Stud1 23.4
Stud3 34.32
Stud4 56.45

 

（四）LinkedList.get()获取元素

Get(int)方法的实现在remove(int)中已经涉及过了。首先判断位置信息是否合法（大于等于0，小于当前LinkedList实例的Size），然后遍历到具体位置，获得节点的业务数据（element）并返回。

4.1：方法

get(int index)：返回此列表中指定位置处的元素。
getFirst()：返回此列表的第一个元素。
getLast()：返回此列表的最后一个元素。
indexOf(Object o)：返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

4.2：源码分析

注意细节：位运算与直接做除法的区别。先将index与长度size的一半比较，如果index<size/2，就只从位置0往后遍历到位置index处，而如果index>size/2，就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历
 

// 获取双向链表中指定位置的节点    
private Entry < E > entry(int index) {
if (index < 0 || index >= size) throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
Entry < E > e = header;
// 获取index处的节点。    
// 若index < 双向链表长度的1/2,则从前先后查找;    
// 否则，从后向前查找。    
if (index < (size >> 1)) {
    for (int i = 0; i <= index; i++) e = e.next;
} else {
    for (int i = size; i > index; i--) e = e.previous;
}
return e;
}

（五）LinkedList.remove()删除数据

5.1：方法

remove()：获取并移除此列表的头（第一个元素）。
remove(int index)：移除此列表中指定位置处的元素。
remove(Objec o)：从此列表中移除首次出现的指定元素（如果存在）。
removeFirst()：移除并返回此列表的第一个元素。
removeFirstOccurrence(Object o)：从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
removeLast()：移除并返回此列表的最后一个元素。
removeLastOccurrence(Object o)：从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。

5.2：源码分析

（1）几个remove方法最终都是调用了一个私有方法：remove(Entry<E> e)，只是其他简单逻辑上的区别。下面分析remove(Entry<E> e)方法。

private E remove(Entry < E > e) {
    if (e == header) throw new NoSuchElementException();
    // 保留将被移除的节点e的内容
    E result = e.element;
    // 将前一节点的next引用赋值为e的下一节点
    e.previous.next = e.next;
    // 将e的下一节点的previous赋值为e的上一节点
    e.next.previous = e.previous;
    // 上面两条语句的执行已经导致了无法在链表中访问到e节点，而下面解除了e节点对前后节点的引用
    e.next = e.previous = null;
    // 将被移除的节点的内容设为null
    e.element = null;
    // 修改size大小
    size--;
    modCount++;
    // 返回移除节点e的内容
    return result;
}

（2）由于删除了某一节点因此调整相应节点的前后指针信息，如下：
e.previous.next = e.next;//预删除节点的前一节点的后指针指向预删除节点的后一个节点。
e.next.previous = e.previous;//预删除节点的后一节点的前指针指向预删除节点的前一个节点。
 

（3）清空预删除节点：交给gc完成资源回收，删除操作结束。与ArrayList比较而言，LinkedList的删除动作不需要“移动”很多数据，从而效率更高。
e.next = e.previous = null;
e.element = null;
 

（六）LinkedList.clear() 清除数据源码分析

清除数据clear()源码如下：

public void clear() {
    Entry<E> e = header.next;
    // e可以理解为一个移动的“指针”，因为是循环链表，所以回到header的时候说明已经没有节点了
    while (e != header) {
        // 保留e的下一个节点的引用
        Entry<E> next = e.next;
        // 解除节点e对前后节点的引用
        e.next = e.previous = null;
        // 将节点e的内容置空
        e.element = null;
        // 将e移动到下一个节点
        e = next;
    }
    // 将header构造成一个循环链表，同构造方法构造一个空的LinkedList
    header.next = header.previous = header;
    // 修改size
    size = 0;
    modCount++;
}

（七）LinkedList.add() 增加方法以及原理

LinkedList add(E e)将指定元素添加到此列表的结尾。

7.1：源码分析

（1）addBefore(E e,Entry<E> entry)方法是个私有方法，所以无法在外部程序中调用（当然，这是一般情况，你可以通过反射上面的还是能调用到的）。
（2）addBefore(E e,Entry<E> entry)先通过Entry的构造方法创建e的节点newEntry（包含了将其下一个节点设置为entry，上一个节点设置为entry.previous的操作，相当于修改newEntry的“指针”），之后修改插入位置后newEntry的前一节点的next引用和后一节点的previous引用，使链表节点间的引用关系保持正确。之后修改和size大小和记录modCount，然后返回新插入的节点。

// 将元素(E)添加到LinkedList中
public boolean add(E e) {
// 将节点(节点数据是e)添加到表头(header)之前。
// 即，将节点添加到双向链表的末端。
addBefore(e, header);
return true;
}
public void add(int index, E element) {
    addBefore(element, (index == size ? header: entry(index)));
}
private Entry < E > addBefore(E e, Entry < E > entry) {
    Entry < E > newEntry = new Entry < E > (e, entry, entry.previous);
    newEntry.previous.next = newEntry;
    newEntry.next.previous = newEntry;
    size++;
    modCount++;
    return newEntry;
} 
public void addFirst(E e) {
addBefore(e, header.next);
}
public void addLast(E e) {
    addBefore(e, header);
}
private Entry<E> addBefore(E e, Entry<E> entry) {
    //利用Entry构造函数构建一个新节点 newEntry，
    Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
    //修改newEntry的前后节点的引用，确保其链表的引用关系是正确的
    newEntry.previous.next = newEntry;
    newEntry.next.previous = newEntry;
    //容量+1
    size++;
    //修改次数+1
    modCount++;
    return newEntry;
}

7.2：添加原理

下面分解“添加第一个数据”的步骤：

第一步：初始化后LinkedList实例的情况：

第二步：初始化一个预添加的Entry实例（newEntry）。

Entry newEntry = newEntry(e, entry, entry.previous);

第三步：调整新加入节点和头结点（header）的前后指针。

newEntry.previous.next = newEntry;

newEntry.previous即header，newEntry.previous.next即header的next指向newEntry实例。在上图中应该是“4号线”指向newEntry。

newEntry.next.previous = newEntry;

newEntry.next即header，newEntry.next.previous即header的previous指向newEntry实例。在上图中应该是“3号线”指向newEntry。

调整后如下图所示：

图——加入第一个节点后LinkedList示意图

下面分解“添加第二个数据”的步骤：

第一步：新建节点。

图——添加第二个节点

第二步：调整新节点和头结点的前后指针信息。

图——调整前后指针信息

添加后续数据情况和上述一致，LinkedList实例是没有容量限制的。

总结，addBefore(E e,Entry<E> entry)实现在entry之前插入由e构造的新节点。而add(E e)实现在header节点之前插入由e构造的新节点。为了便于理解，下面给出插入节点的示意图。

看上面的示意图，结合addBefore(E e,Entry<E> entry)方法，很容易理解addFrist(E e)只需实现在header元素的下一个元素之前插入，即示意图中的一号之前。addLast(E e)只需在实现在header节点前（因为是循环链表，所以header的前一个节点就是链表的最后一个节点）插入节点（插入后在2号节点之后）。