LinkedList 底层结构 和 ArrayList 比较

7.1 LinkedList 的全面说明

7.2 LinkedList 的底层操作机制

package com.xjz.list_;


public class LinkedList01 {
    public static void main(String[] args) {
        //模拟一个简单的双向链表

        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node qdy = new Node("秋刀鱼");

        //连接三个结点，形成双向链表
        //jack-> tom-> qdy
        jack.next = tom;
        tom.next = qdy;
        //qdy-> tom-> jack
        qdy.pre = tom;
        tom.pre = jack;

        Node first = jack; //让 first 引用指向Jack，就是双向链表的头结点
        Node last = qdy; //让 last 引用指向qdy，就是双向链表的尾结点

        //演示，从头到尾进行遍历
        System.out.println("===从头到尾进行遍历===");
        while (true) {
            if (first == null) {
                break;
            }
            //输出first信息
            System.out.println(first);
            first = first.next;
        }

        //演示，从尾到头进行遍历
        System.out.println("===从头到尾进行遍历===");
        while (true) {
            if (last == null) {
                break;
            }
            //输出last信息
            System.out.println(last);
            last = last.pre;
        }

        //演示链表的添加对象/数据，是多么的方便
        //要求，在tom----秋刀鱼之间，插入一个对象smith

        //1.先创建一个Node结点，name 就是 smith
        Node smith = new Node("smith");
        //下面就把smith 加入到双向链表中
        smith.next = qdy;
        smith.pre = tom;
        qdy.pre = smith;
        tom.next = smith;

        //让first再次指向jack
        first = jack; // 让first引用指向jack，就是双向链表的头结点

        System.out.println("===从头到尾进行遍历===");
        while (true) {
            if (first == null) {
                break;
            }
            //输出first信息
            System.out.println(first);
            first = first.next;
        }
        
        //让last再次指向qdy
        last = qdy; // 让first引用指向jack，就是双向链表的头结点

        System.out.println("===从尾到头进行遍历===");
        while (true) {
            if (last == null) {
                break;
            }
            //输出last信息
            System.out.println(last);
            last = last.pre;
        }

    }
}

//定义一个 Node 类，Node 对象 表示双向链表的一个结点
class Node {
    public Object item; //真正存放数据
    public Node next; //指向后一个结点
    public Node pre; //指向前一个节点

    public Node(Object name) {
        this.item = name;
    }

    @Override
    public String toString() {
        return "Node name=" + item;
    }
}

7.3 LinkedList 的增删改查案例

package com.xjz.list_;

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

@SuppressWarnings({"all"})
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();//这里默认删除的是第一个结点
        //linkedList.remove(2); //从0开始，删除第三个元素

        System.out.println("linkedList=" + linkedList);

        //修改某个结点对象
        linkedList.set(1,999);
        System.out.println("linkedList=" + linkedList);

        //得到某个结点对象
        //get(1) 是得到双向链表的第二个对象
        Object o = linkedList.get(1);
        System.out.println(o); //999

        //因为 linkedList 是 实现了 List 接口，遍历方式
        System.out.println("===LinkedList 遍历迭代器===");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println("next=" + next);
        }

        System.out.println("===LinkedList 遍历迭代器增强for===");
        for (Object o1 :linkedList) {
            System.out.println("o1=" + o1);
        }

        System.out.println("===LinkedList 遍历普通for===");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }


        //源码阅读.
        /* 1. LinkedList linkedList = new LinkedList();
                 public LinkedList() {}
        2. 这时 linkeList 的属性 first = null last = null
        3. 执行 添加
            public boolean add(E e) {
                linkLast(e);
                return true;
            }
        4.将新的结点，加入到双向链表的最后
         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++;
         }
         */
        /*
       老韩读源码 linkedList.remove(); // 这里默认删除的是第一个结点
        1. 执行 removeFirst
            public E remove() {
              return removeFirst();
            }
        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;
                final Node<E> next = f.next;
                f.item = null;
                f.next = null; // help GC
                first = next;
                if (next == null)
                    last = null;
                else
                    next.prev = null;
                size--;
                modCount++;
                return element;
            }
            */
    }
}

ArrayList 和 LinkedList 比较

8.1 ArrayList 和 LinkedList 的比较