1.结构

 

1. 承继

 

  该类承继自 AbstractSequentialList 这一是由于他是一个顺序的文件目录,所以说承继的是一个顺序的 List

 

2. 进行

 

这一类进行的插口比较多,具体下列:

 

  1. 最开始这一类是一个 List 自然有 List 插口
  2. 接着由于这一类是完成了 Deque 这一插口是二端序列的插口,所以说它是具有双端队列的特征的。后面大伙儿会看到很多相关双端队列的方法
  1. 接着就是两个融合构架不容置疑会实现的两个插口 Cloneable, Serializable 。

3. 关键词段名

 

1. 特性列名

 

    transient int size = 0;
    //偏重单单链表的头表杆和尾表杆
    transient Node<E> first;
    transient Node<E> last;

 

2. Node 节点

 

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

 

4. 重要方法 简述

 

  1. ctor-2
  2. addFirst
  1. addLast
  2. addAll
  1. add
  2. indexOf
  1. lastIndexOf
  2. Peek 得到第一个元素,是 null 就返回 null
  1. peekFirst/Last  得到第一个最后一个元素
  2. poll 删除第一个元素并返回 没有返回 null
  1. pollFirst/Last
  2. offer 开启了 add
  1. offerFirst/Last
  2. push
  1. pop
  2. set
  1. Remove(noArgs) == removeFirst  承继自 deque
  2. remove(E e) 检索删除
  1. read/writeObject  或者手拉式的案例化,原因一样,马上创建对象元素而没有 pre/next

 

2. 结构涵数分析

 

仅有两个构造方法。在这其中一个是默认的空构造也就是转换成一个空的 LinkedList 除此之外一个就是接受一个 Collection 插口。里面开启了 PutAll 方法 。

 

    public LinkedList() {
    }

    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

 

3. 重要方法 分析

 

1. add

 

这一方法 就马上启动了 linkLastlinkLast 里面就是马上把元素再加上到元素的结尾。

 

 public boolean add(E e) {
        linkLast(e);
        return true;
}

void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size  ;
        modCount  ;
}

 

2. addFrist/Last

 

这两个方法 跟上边一样或者开启了 linkFirstlinkLast 所以说这好好几个再加上修改的方法 基本上上都是靠最最底层的一样的方法 进行的。

 

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

public void addLast(E e) {
   linkLast(e);
}

 

3. addAll

 

该方法 我们在构造方法中也看到了,在它里面进行的情形下和 ArRayList 一样是马上把融合转成二维数组,接着进行创建新的节点插到进来。

 

public boolean addAll(int index, Collection<? extends E> c) {
       checkPositionIndex(index);

       Object[] a = c.toArray();
       int numNew = a.length;
       if (numNew == 0)
           return false;

       Node<E> pred, succ;
       if (index == size) {
           succ = null;
           pred = last;
       } else {
           succ = node(index);
           pred = succ.prev;
       }

       for (Object o : a) {
           @SuppressWarnings("unchecked") E e = (E) o;
           Node<E> newNode = new Node<>(pred, e, null);
           if (pred == null)
               first = newNode;
           else
               pred.next = newNode;
           pred = newNode;
       }

       if (succ == null) {
           last = pred;
       } else {
           pred.next = succ;
           succ.prev = pred;
       }

       size  = numNew;
       modCount  ;
       return true;
   }

 

4. indexOf

 

这一方法 里面采用 for 循环系统系统软件分析xml,解析xml的情形下是重新开始连接点慢慢解析xml,只需找寻那一个元素立刻返回,而不再度进行出来。

 

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

 

5. lastIndexOf

 

这一方法 和上面的方法 进行的方式一样的,但是注意这一方法 的意思是找寻最后一个与之匹配的元素,他并并并不是从头开始找,仅仅马上从尾节点慢慢解析xml。做法一样找寻即停止。

 

6. peek/peekFirst/peekLast

 

peek 方法 的意思就是返回最顶端的元素,倘若这一元素不容易有,那么马上返回 null 。之后也是有 peekFirst 这类的就是返回第一个的寓意。底层开启的就是头连接点的特性。这类方法 事实上在 Collection 插口中是不可能有的,重要就是因为他完成了 Deque 所发生的的新特性。

 

7. poll/pollFirst/pollLast

 

poll 用以删除头连接点并返回,倘若不容易有就返回 null
剩下的2个方法 一样。

 

8. offer/offerFirst/offerLast

 

插到头连接点。

 

9. push/pop

 

底层的方法 就是 addFirst 和 removeFirst

 

10. remove(noargs)/remove(E e)

 

无参的开启 removeFirst 有关键主要参数的就是去检索接着删除。

 

11. read/writeObject

 

这里同 ArrayList 本身手拉式的进行了创建对象。创建对象的情形下只是对 Node 节点里面的元素进行创建对象,而前轮驱动事后马上省掉,也是节约房间内室内空间的想法。

 

4.归纳

 

好,事实上在充分掌握 ArrayList 的基础之上看文中就比较好掌握,里面的操作过程更加简单。只是注意一下二者的区别,完成了 Deque 造成的很多 新的方法 。