Java自学笔记—LinkedList

Java自学笔记—LinkedList

特点

底层实现了双向列表和双向队列的特点，list和last属性指向首节点和末节点
每个节点(Node对象)，有prev、next、item三个属性，prev指向前一个，next指向后一个，实现双向列表
可以添加任意元素，可重复
线程不安全

自定义双向链表

定义一个Node类

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

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

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

使用

/**
 * @author Lspero
 * @version 1.0
 */

@SuppressWarnings("all")
public class LinkedList01 {
    public static void main(String[] args) {
        //模拟简单的双向列表

        //创建对象(孤立)
        Node jack = new Node("jack");
        Node tom  = new Node("tom");
        Node mary = new Node("mary");

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

        //首尾节点
        Node first = jack;
        Node last = mary;

        //遍历
        while (true){
            if(first == null){
                break;
            }
            //输出first信息
            System.out.println(first);
            first = first.next;//最后一个next=null
        }

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

        //添加数据
        Node lspero = new Node("lspero");
        jack.next = lspero;
        lspero.pre = jack;
        lspero.next = tom;
        tom.pre = lspero;

        //添加后
        System.out.println("=====添加后=====");
        first = jack;//重置fist
        while (true){
            if(first == null){
                break;
            }
            //输出first信息
            System.out.println(first);
            first = first.next;//最后一个next=null
        }
    }
}

List常用方法

/**
 * @author Lspero
 * @version 1.0
 */
public class List_ {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        // 有序存储，且可以重复
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        list.add("tom");
        System.out.println("list = " + list);
        
        // 支持索引
        System.out.println(list.get(3));
        System.out.println("================");
        
        // 遍历方式  迭代器  增强for  普通for
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.print(next);
        }
        
        System.out.println();
        for (Object o : list) {
            System.out.print(o);
        }
        
        System.out.println();
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
    }
}

remove( )和add( )源码

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();
        /*
        1.执行removeFirst()
        public E remove() {
            return removeFirst();
        }
        2.执行unlinkFirst(f)
        public E removeFirst() {
            final Node<E> f = first;
            if (f == null)
                throw new NoSuchElementException();
            return unlinkFirst(f);
        }

        3.将第一个节点拿掉
        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;
        }
        * */

        System.out.println("删除后linkedlist = " + linkedList);

        System.out.println(linkedList.get(1));
        //遍历，实现List，可以用增强for、迭代器、普通for
        /*
          1.LinkedList linkedList = new LinkedList();
              public LinkedList(){}
              这时first = null  last = null
          2.执行添加add
              public boolean add(E e) {
                    linkLast(e);
                    return true;
              }
           3.将新节点加到双向链表最后
              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++;
                }
        * */

        // ArrayList改查效率高，LinkedList增删效率高
        // ArrayList  jdk1.2  效率高，不安全  无参默认0 第一次10，1.5倍扩
        // Vector     jdk1.0  效率不高，安全  无参默认10，2倍扩
    }
}

List各实现子类对比

ArrayList改查效率高，LinkedList增删效率高，线程都不安全，常用ArrayList
ArrayList jdk1.2 效率高，不安全 无参默认0 第一次10，1.5倍扩
Vector jdk1.0 效率不高，安全 无参默认10，2倍扩