java集合分析(9):LinkedList

移动开发 waitig 426℃ 百度已收录 0评论

先前我们分析了ArrayList , 我们知道 ArrayList 是以数组实现的,遍历时很快,但是插入、删除时都需要移动后面的元素,效率略差些。这篇我们来看看LinkedList,它是以双向链表实现的,插入、删除时只需要改变前后两个节点指针指向即可。

什么是LinkedList

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口,能对它进行队列操作。
LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口,即覆盖了函数clone(),能克隆。
LinkedList 实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输。
LinkedList 是非同步的。

LinkedList的成员变量

//链表的大小 size 
transient int size = 0;
//指向第一个节点  
transient Node<E> first;
//指向最后一个节点
transient Node<E> last;

Node

Node是LinkedList的静态内部类,每个节点指向前一个节点和后一个节点,这就是双向链表节点。


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

LinkedList的构造函数

 //默认构造函,创建一个空的链表
 public LinkedList() {
 }

  //创建一个包含“c集合”的LinkedList
  public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
 }

LinkedList的方法

1.关键的几个内部方法

  //插入到头部
  private void linkFirst(E e) {
        //头结点赋值给f
        final Node<E> f = first;
        //新建一个节点,并且头结点指针指向新创建的结点newNode
        final Node<E> newNode = new Node<>(null, e, f);
        //newNode赋值给结点first
        first = newNode;
        //如果f是null,说明之前链表中没有结点,所以last指向newNode
        if (f == null)
            last = newNode;
        else
          //原来的第一个节点(现在的第二个)头部指向新建的头结点
            f.prev = newNode;
        size++;
        modCount++;
    }

   //添加到尾部
    void linkLast(E e) {
       //尾结点赋值给f
        final Node<E> l = last;
         //新建一个节点,并且尾结点指针指向新创建的结点newNode
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
         //如果f是null,说明之前链表中没有结点,则新建的节点也是第一个节点
        if (l == null)
            first = newNode;
        else
         //原来的尾节点尾部指向新建的尾节点
            l.next = newNode;
        size++;
        modCount++;
    }

 //在指定节点前插入一个元素
 void linkBefore(E e, Node<E> succ) {
        // 获取指定节点 succ 前面的一个节点
        final Node<E> pred = succ.prev;
        //新建一个节点,头部指向 succ 前面的节点,尾部指向 succ 节点,数据为 e
        final Node<E> newNode = new Node<>(pred, e, succ);
        //让 succ 前面的节点指向新建的节点
        succ.prev = newNode;
        //如果 succ.prev前面的节点为空,说明 succ 就是第一个节点,那现在新建的节点就变成第一个节点了
        if (pred == null)
            first = newNode;
        else
        //如果前面有节点,则将新建的结点指向pred.next
            pred.next = newNode;
        size++;
        modCount++;
    }

  //删除头节点并返回该节点上的值
  private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        // 获取该节点的值赋值给element 
        final E element = f.item;
        //获取头节点后面的一个节点
        final Node<E> next = f.next;、
        //使头节点上数据为空,尾部指向null
        f.item = null;
        f.next = null; // help GC
        //将头节点后面的一个节点设置成第一个
        first = next;
        //如果头节点后面的节点为 null,说明链表中只有一个节点
        if (next == null)
            last = null;
        else
        //如果链表中不止一个节点,则将next.prev设为null
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

    //删除尾节点并返回该节点上的值
 private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        // 获取该节点的值赋值给element 
        final E element = l.item;
        // 获取尾节点前面的一个节点
        final Node<E> prev = l.prev;
        //使尾节点上数据为空,头部指向null
        l.item = null;
        l.prev = null; // help GC
        //将尾节点前面的一个节点设置成最后一个
        last = prev;
        //如果尾节点前面的节点为 null,说明链表中只有一个节点
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

//删除某个指定节点并返回该节点上的值
E unlink(Node<E> x) {
        // assert x != null;
        // 获取该节点的值赋值给element 
        final E element = x.item;
        //获取该节点后面的一个节点
        final Node<E> next = x.next;
        //获取该节点前面的一个节点
        final Node<E> prev = x.prev;

        //如果前面没有节点,说明 x 是第一个
        if (prev == null) {
            first = next;
        } else {
           //如果前面有节点,让前面节点跨过 x 直接指向 x 后面的节点
            prev.next = next;
            x.prev = null;
        }
       //如果后面没有节点,说 x 是最后一个节点
        if (next == null) {
            last = prev;
        } else {
          //后面有节点,让后面的节点指向 x 前面的
            next.prev = prev;
            x.next = null;
        }
        x.item = null;
        size--;
        modCount++;
        return element;
    }

    //获取指定位置的节点
    Node<E> node(int index) {
        // assert isElementIndex(index);
        // size>>1右移一位代表除以2,这里使用简单的二分方法,判断index与list的中间位置的距离
        if (index < (size >> 1)) {
            Node<E> x = first;
            // 如果index小于size的一半,则从头部向后遍历(next)
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
           // 如果index大于size的一半,则从尾部倒着遍历(previous)
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

2.添加元素

 //添加元素到头部
 public void addFirst(E e) {
        linkFirst(e);
 }

 //添加元素到尾部
 public void addLast(E e) {
        linkLast(e);
 }

 //添加元素到尾部
 public boolean add(E e) {
        linkLast(e);
        return true;
 }

 //添加一个集合的元素
 public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
 }

 //在指定位置添加一个集合
 public boolean addAll(int index, Collection<? extends E> c) {
        //检查index是否越界
        checkPositionIndex(index);
        //将集合c转成数组
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;
        //创建两个节点,分别指向要插入位置前面和后面的节点
        Node<E> pred, succ;
        //index == size说明已经是尾部,我们要在尾部添加元素
        if (index == size) {
            succ = null;
            pred = last;
        } else {
        //通过node(index)获取当前节点并给succ,然后通过succ.prev获取前一个节点并赋值给pred 
            succ = node(index);
            pred = succ.prev;
        }

        //遍历要添加内容的数组
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            //如果 pred 为空,说明新建的这个是头节点
            if (pred == null)
                first = newNode;
            else
             //将newNode指向给 pred.next
                pred.next = newNode;
            pred = newNode;
        }
       //如果 succ 为null,说明要插入的位置就是尾部,则将pred指向给last
        if (succ == null) {
            last = pred;
        } else {
          //否则 pred 指向后面的元素
            pred.next = succ;
            succ.prev = pred;
        }
      //元素个数增加
        size += numNew;
        modCount++;
        return true;
    }

    //在指定位置添加元素
    public void add(int index, E element) {
        //检查index是否越界
        checkPositionIndex(index);
        //index == size,说明已经是尾部,直接在尾部添加元素
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

  public boolean offer(E e) {
        return add(e);
    }

  public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

   public boolean offerLast(E e) {
        addLast(e);
        return true;
   }


  public void push(E e) {
        addFirst(e);
   }

3.删除元素

  //删除头节点并返回该节点上的值
  public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

//删除尾节点并返回该节点上的值
public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
//删除包含指定元素的节点
public boolean remove(Object o) {
        if (o == null) {
            //遍历删除
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

//清空双向链表
public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        //从头节点逐个向后遍历
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        //头结点和尾节点置null
        first = last = null;
        size = 0;
        modCount++;
  }

 //删除指定位置的节点
 public E remove(int index) {
         //检查index是否越界
        checkElementIndex(index);
        return unlink(node(index));      
 }

 //删除头节点并返回删除的数据
 public E remove() {
        return removeFirst();
 }

 //删除头节点并返回删除的数据
 public E pop() {
        return removeFirst();
 }

 //删除列表中第一出现o的节点 
 public boolean removeFirstOccurrence(Object o) {
        return remove(o);
 }

 //逆向遍历,删除第一次出现o的节点  
 public boolean removeLastOccurrence(Object o) {
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

3.查询,修改,是否包含元素

//返回头节点的元素
public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
}

//返回尾节点的元素值
public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
}

//获取指定索引位置节点的元素值
public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
}

//返回头节点的元素值    
public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}

//返回头节点的元素值
public E element() {
        return getFirst();
}

//检索头节点,若空则返回null,不为空则返回其元素值并删除头节点  
public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
}

//返回头节点的元素值
public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}

//返回尾节点的元素值
public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
}

//检索头节点,若空则返回null,不为空则返回其元素值并删除头节点 
public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
}

//检索尾节点,若空则返回null,不为空则返回其元素值并删除尾节点 
public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
}

//替换指定索引位置节点的元素值  
public E set(int index, E element) {
        checkElementIndex(index);
        //返回指定索引位置的节点
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
}

//判断列表中是否包含元素o  
public boolean contains(Object o) {
        return indexOf(o) != -1;
}

//返回列表中第一次出现o的位置,若不存在则返回-1 
public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            //从头节点开始向后遍历所有节点
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
}

//逆向遍历,返回第一出现o的位置,不存在则返回-1  
public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
             //从尾节点开始向前遍历所有节点
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
 }

4.数组转换

public Object[] toArray() {
        //新建一个数组,大小为size
        Object[] result = new Object[size];
        int i = 0;
        //遍历所有节点
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        return result;
}

public <T> T[] toArray(T[] a) {
        if (a.length < size)
         //创建一个长度为size的字符串数组a,类型和oldArray的一样,在Java中数组也可以作为Object对象 
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;

        if (a.length > size)
            a[size] = null;

        return a;
}

5.迭代器

//逆序迭代器,调用descendingIterator()得到LinkedList对象的从后往前的遍历器。
public Iterator<E> descendingIterator() {
        return new DescendingIterator();
}

/**
 * Adapter to provide descending iterators via ListItr.previous
 */   
private class DescendingIterator implements Iterator<E> {
        private final ListItr itr = new ListItr(size());
        public boolean hasNext() {
            return itr.hasPrevious();
        }
        public E next() {
            return itr.previous();
        }
        public void remove() {
            itr.remove();
        }
}
 //链表遍历器,通过调用listIterator(int index)返回指定位置开始的链表遍历器。
 public ListIterator<E> listIterator(int index) {
        //检查index是否越界
        checkPositionIndex(index);
        //返回从指定位置开始的链表遍历器
        return new ListItr(index);
    }

    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;
        }
        //判断是否有上一个结点
        public boolean hasPrevious() {
            return nextIndex > 0;
        }

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {
            return nextIndex;
        }

        public int previousIndex() {
            return nextIndex - 1;
        }

        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while (modCount == expectedModCount && nextIndex < size) {
                action.accept(next.item);
                lastReturned = next;
                next = next.next;
                nextIndex++;
            }
            checkForComodification();
        }
//与ArrayList类似,也是通过一个属性modCount来判断是否在取得遍历器之后对链表进行结构变化的操作,如果有则抛出ConcurrentModificationException异常
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

6.LinkedList遍历

public class Test {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // 通过Iterator遍历LinkedList
        iterator(getLinkedListData());

        // 通过快速随机访问遍历LinkedList
        for1(getLinkedListData());

        // 通过forEach循环遍历LinkedList
        for2(getLinkedListData());

    }

    private static LinkedList getLinkedListData() {
        LinkedList llist = new LinkedList();
        for (int i = 0; i < 100000; i++)
            llist.addLast(i);

        return llist;
    }

    /**
     * 通过迭代器遍历LinkedList
     */
    private static void iterator(LinkedList<Integer> list) {

        // 记录开始时间
        long start = System.currentTimeMillis();
        Iterator iter = list.iterator(); 
        while (iter.hasNext()) {
            iter.next();
        }

        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("迭代器遍历:" + interval + " ms");
    }

    /**
     * 通过快速随机访问遍历LinkedList
     */
    private static void for1(LinkedList<Integer> list) {

        // 记录开始时间
        long start = System.currentTimeMillis();

        int size = list.size();
        for (int i = 0; i < size; i++) {
            list.get(i);
        }
        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("快速随机访问:" + interval + " ms");
    }

    /**
     * 通过forEach循环来遍历LinkedList
     */
    private static void for2(LinkedList<Integer> list) {

        // 记录开始时间
        long start = System.currentTimeMillis();

        for (Integer integ : list){

        }


        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("forEach循环:" + interval + " ms");
    }
}

运行结果:
这里写图片描述
通过上面运行结果可以看到,遍历LinkedList获取元素值时,使用迭代器或forEach效率最高。使用快速随机访问效率很低 , 所以最好不要通过随机访问去遍历LinkedList。

ArrayList与LinkedList的区别::

ArrayList

  • 底层基于数组实现的,支持随机访问,查询和获取数据效率高

  • 插入或删除一个元素index之后元素都被会移动(向后或者向前),所以添加/删除数据效率不高

  • 有容量 , 每次达到阈值都需要扩容,并且在list的结尾会预留一定的容量空间

LinkedList

  • 底层基于双端循环链表,不支持随机访问,添加或删除元素只会影响周围的两个节点,开销很低,所以添加或删除效率高

  • 只能顺序遍历,无法按照索引获得元素,因此查询效率不高

  • 没有固定容量,不需要扩容;但它需要更多的内存,由于它每个节点都需要存储前后节点的信息,所以它的每一个元素都需要消耗相当的空间

总结:

ArrayList和LinkedList各有优缺点,所以当我们需要经常查找元素,则可以选择ArrayList,效率上会好些,如果需要对列表进行添加或删除操作频繁,则选择LinkedList会更好。

Thanks:

http://blog.csdn.net/u010370082/article/details/45046755

http://blog.csdn.net/xujian_2014/article/details/46806999


本文由【waitig】发表在等英博客
本文固定链接:java集合分析(9):LinkedList
欢迎关注本站官方公众号,每日都有干货分享!
等英博客官方公众号
点赞 (0)分享 (0)