LinkedList源码解析

参考：

https://blog.csdn.net/qq_38304320/article/details/103737343

https://blog.csdn.net/kai3123919064/article/details/90343320

https://blog.csdn.net/nisemono_ct/article/details/95620007

 

 

 

 

 

 

LinkedListed的add(index,element)源码解析

LinkedList<Integer> list = new LinkedList<>();
list.add(0,1);
System.out.println(list);

list.add(1,2);
System.out.println(list);

list.add(1,3);
System.out.println(list);

list.add(0,4);
System.out.println(list);

list.add(2,5);
System.out.println(list);

执行结果：

[1]
[1, 2]
[1, 3, 2]
[4, 1, 3, 2]
[4, 1, 5, 3, 2]

public void add(int index, E element) {
    //检查index是否合法，即 index>=0 && index <=size
            checkPositionIndex(index);
            //如果index为链表大小，说明只需要尾节点直接插入即可
            if (index == size)
        linkLast(element);
    else
    //在index之前插入元素
        linkBefore(element, node(index));
}

 

linkLast方法，正常插入方法

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

   
//节点的数据结构
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;
        }
    }

 

 

 

linkBefore方法

/**
 * Inserts element e before non-null Node succ.
 */
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    //succ的前驱节点为pred eg:1->2 2的前驱节点为1
    final Node<E> pred = succ.prev;
    //生成一个新的节点newNode 通过 succ，succ的前驱节点，以及元素e
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
//    如果前驱节点为null，那么将新节点直接弄在第一个节点上
/*
  eg: 1->2->3
  list.add(0,4)
   succ=1
   pred = null
将4直接插在第一个节点上   新链表为 4->1->2->3
*/
    if (pred == null)
        first = newNode;
    else
//如果前驱节点不null    
/*
  eg: 4->1->2->3
  list.add(2,5)
   succ=2
   pred = 1
将5pred即节点值为1的后面   新链表为 4->1->5->2->3
*/
    
        pred.next = newNode;
    size++;
    modCount++;
}

 

 

node(index)方法
返回指定索引的节点
首先后判断索引是否小于总数的一半，如果小于则会正向遍历，否则会反向遍历
比如现在链表为 1 -> 2 -> 3 -> 4
node(1)：2
node(2)：3

/**
 * 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++)//每次迭代前都会测试布尔表达式:i<index，所以如果index=0，x=x.next不执行，返回first节点
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

 

总结
LinkedList list = new LinkedList<>();
list.add(0,1); list: 1
list.add(1,2); list: 1->2
list.add(1,3); list: 1-3->2
list.add(0,4); list: 4->1->3->2
list.add(2,5); list: 4->1->5->3->2

 

 

 

 

 

 

 

 

 

Linkedlist的add()和get()方法源码解析

add()方法

• 调用add()方法添加元素,会调用linkedlast(),把新添加的元素放在原链表最后一位
• 首先获取原链表最后一个元素,根据当前输入的元素构建一个node,把原最后一位元素最为新构建的元素中pre对应的变量
• 新构建的node覆盖之前最后一个node变量
• 判断为添加前的最后一位是否为空,如果为空,新添加的一个node也是first变量对应的元素
• 如果添加前的最后一位不为空,则未添加前的最后一位元素的next变量被新添加的元素覆盖
• 链表长度加1,链表修改统计加1

   public boolean add(E e) {
        // 调用 linkLast方法,把新添加的元素添加到链表的最后一个位置
        linkLast(e);
        return true;
    }

    // 把元素添加在链表的最后一个位置的方法
    void linkLast(E e) {
        // 获取链表中最后一个元素
        final Node<E> l = last;
        // 该方法是把元素放在最后一个位置,所以创建一个新的node,变量前一个元素是没添加前最后一个
        final Node<E> newNode = new Node<>(l, e, null);
        // 把新添加的元素作为最后一个
        last = newNode;
        // 判断新元素未添加前的最后一个是否是空,如果是,则新添加的元素即是最后一个,也是第一个
        if (l == null)
            // 新添加的元素赋给第一个
            first = newNode;
        else
            // 如果不为空,则原来最有一个元素的next遍历绑定新添加的元素
            l.next = newNode;
        // 链表长度加1,修改次数加1
        size++;
        modCount++;
    }

 

get()方法

• 首先,校验输入的下标是否满足linkedlist中的长度范围,如果不满足,抛出异常
• 如果满足,调用node()方法,首先把原长度除以2,判断当前输入的下标是在上半部分还是下半部分
• 如果在上半部分,从上往下遍历,如果在下半部分,从后往前遍历.
• 最后一个元素就是要找的元素

    public E get(int index) {
        // 检查索引是否规范
        checkElementIndex(index);
        // 获取指定下标的元素
        return node(index).item;
    }

    // 判断索引是否规范
    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    // 判断索引是否在链表长度的范围内
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

     Node<E> node(int index) {
        // 把链表的长度向右移一个单位,也就是除以2, 判断录入的索引是在前半段还是后半段
        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;
        }
    }

 

 

 

 

 

 

链表转数组：toArray()、toArray(T[] a) 

  public Object[] toArray() {
        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)//数组a长度过短，重新生成size长度的数组
            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长度的数据被GC
            a[size] = null;

        return a;
    }

以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。

 

参考例子和执行结果：

  String[] planets=new String[]{"Mecury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
        LinkedList linklisted=new LinkedList(Arrays.asList(planets));

        linklisted.add(3,"Position");
        System.out.println("linkdelist"+linklisted.toString());

        String[] newPlanets0= (String[]) linklisted.toArray(new String [0]);//少于size长度会重新实例化size长度的数组
        System.out.println("ArrayList0"+Arrays.toString(newPlanets0));

        String[] newPlanets1= (String[]) linklisted.toArray(new String [20]);//高于size长度直接使用此数组，超出链表长度的值为null
        System.out.println("ArrayList1"+Arrays.toString(newPlanets1));

        String[] newPlanets2 = (String[]) linklisted.toArray(new String[linklisted.size()]);//相同长度对性能和内存最友好
        System.out.println("ArrayList2"+Arrays.toString(newPlanets2));

        Object[] newPlanets3 = linklisted.toArray();//toArray返回的是Object数组，不能转到String类型
        System.out.println("ArrayList3"+Arrays.toString(newPlanets3));

 

执行结果：

linkdelist[Mecury, Venus, Earth, Position, Mars, Jupiter, Saturn, Uranus, Neptune]
ArrayList0[Mecury, Venus, Earth, Position, Mars, Jupiter, Saturn, Uranus, Neptune]
ArrayList1[Mecury, Venus, Earth, Position, Mars, Jupiter, Saturn, Uranus, Neptune, null, null, null, null, null, null, null, null, null, null, null]
ArrayList2[Mecury, Venus, Earth, Position, Mars, Jupiter, Saturn, Uranus, Neptune]
ArrayList3[Mecury, Venus, Earth, Position, Mars, Jupiter, Saturn, Uranus, Neptune]

 

 

数组转链表：

LinkedList linklist=new LinkedList(Arrays.asList(array));

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param  c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

数组转换链表的是调用了Arrays.asList方法

static List asList(T… a)
返回由指定数组支持的固定大小的列表。