LinkedList源码解析

package 集合.List;

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListCRUD {
    public static void main(String[] args) {
        LinkedList linkedList =new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println("linkedList="+linkedList);

        //删除一个节点
        linkedList.remove();//这里默认删除的是第一个节点
        System.out.println("linkedList="+linkedList);

        //修改某个节点，按索引来找
        linkedList.set(1,998);
        System.out.println("linkedList="+linkedList);
    //得到某个节点对象
        //get(1)是得到双向链表的第二个对象
        Object o= linkedList.get(1);
        System.out.println("linkedList="+linkedList);
    
        //因为LinkedList是实现List接口，遍历方式
        System.out.println("linkedList迭代器");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }
        System.out.println("linkedList的增强for循环");
        for (Object o1 :linkedList) {
            System.out.println(o1);
        }
        System.out.println("linkedList普通循环");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }

    }
    /*
    //源码解读
    LinkedList linkedList =new LinkedList();
    public LinkedList() {
    }
    2.这是linkedList的first=null last = null;
    3.执行 添加
      public boolean add(E e) {
        linkLast(e);
        return true;
    }
    4.将新的节点加入到双向链表的最后
    第二次指向l指向Node的pre，l引用赋值到pre，所以指向前一个
     void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;//第二次last断掉指向新节点的最后一个
        if (l == null)
            first = newNode;
        else
            l.next = newNode;//第二次l不为空指向下一个节点
        size++;
        modCount++;
    }
1.执行removeFirst
    linkedList.remove();//这里默认删除的是第一个节点
2.执行
public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
    3.执行unlinkFirst 将F指向的双向链表第一个节点拿掉
    private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item; //将f里面的值赋值给element
        final Node<E> next = f.next;   //next是下一个节点f.next指向下一个节点
        f.item = null;//f的值为null，next的指向也为空
        f.next = null; // help GC
        first = next;//next指向为第二个 第一个断掉
        if (next == null)
            last = null;
        else
            next.prev = null;//断上面的pre线，first指向第二个pre
        size--;
        modCount++;
        return element; //返回的值是element则是原先的值
    }
     */
}

/*
ArrayList和LinkedList比较

ArrayList :底层结构：可变数组。增删效率：较低，数组扩容。改查效率：较高

LinkedList :底层结构：双向链表。增删效率：较高，通过链表追加。改查效率：较低
 */