参照JDK源码实现一个LinkedList，分析常用的List集合及其适用场景

List常用集合

ArrayList   ArrayList和Vector是基于数组实现的list类，内部封装动态Object[]数组，ArrayList是线程不安全的。 随机访问性能优良，增删性能较差。
LinkedList   底层链接列表实现, 添加元素比较快，查找慢，适用于增删较多查找较少的情况。同时实现了Deque接口，具有队列的功能
Vector   线程安全，方法名复杂，不再常用

LinkedList在生产中也是非常常用的数据结构，因此为了加深理解我们参照JDK源码实习了一个自己的PLinkedList

接口定义

public interface PLinkedListI<T> {
     public int add(T t); 
    public int remove(T t); 
    public T remove(int index);
    public long size();
    public T get(int index);

    public T getFirst();
    public T getLast();
    public T removeFirst();
    public T removeLast();
}

接口实现

import java.io.Serializable;
import java.util.LinkedList;
import java.util.NoSuchElementException;

public class PLinkedList<T> implements PLinkedListI<T> ,Serializable{   

    private static final long serialVersionUID = 1L;
    transient int size;
    transient Node<T> first;
    transient Node<T> last;

    LinkedList<Integer> linkedList = new LinkedList<>();// TODO

    public PLinkedList() {
        this.size = 0;
    }   

    @Override
    public int add(T t) {
    Node<T> node = new Node<T>(t, null, null);
        if (first == null) {
            first = node;
            last = first;           
        }else{
            Node<T> lastNode = getLastNode();
            lastNode.next = node;
            node.prev = lastNode;
            this.last = node;
        }
        size += 1;
        return 1;
    }

    @Override
    public int remove(T t){
        if (first == null) {
            return 0;
        }
        if (first.item.equals(t)) {//第一个
            removeFirst();          
        }
        Node<T> node = first.next;//第二个
        while (node != null) {
            if (node.item.equals(t)) {
                removeNotFistNode(node);            
            }
            node = node.next;
        }
        return 1;
    }

    @Override
    public T remove(int index) {
        if (first == null) {
            return null;
        }
        if (index == 1) {
            return removeFirst();
        }
        Node<T> node = first;
        while(--index > 0 && node != null){
            node = node.next;
        }

        return removeNotFistNode(node).item;

    }

    @Override
    public long size() {        
        return size;
    }

    @Override
    public T get(int index) {
        if (index > size || first == null) {
            return null;
        }
        Node<T> node = first;
        while(--index >0 && node.next != null){
            node = node.next;
        }
        return node.item;
    }


    private Node<T> getLastNode(){
        if (first == null) {
            last = null;
            return null;
        }else{
            Node<T> node = first;
            while (node.next != null) {
                node = node.next; 
            }
            return node;
        }       
    }

    public T removeFirst(){
        if (first == null) {
            return null;
        }
        return unlinkFirst(first);      
    }

    private T unlinkFirst(Node<T> firstNode) {
        T t = firstNode.item;
        Node<T> localNode = firstNode.next;
        firstNode.item = null;
        firstNode.next = null;
        this.first = localNode;
        if (localNode == null)
            this.last = null;
        else
            localNode.prev = null;
        this.size -= 1;
        return t;
    }

    private Node<T> removeNotFistNode(Node<T> node){
        //去除中间的一个节点
        Node<T> prevNode = node.prev;
        Node<T> nextNode = node.next;//可能为空
        prevNode.next = node.next;
        if (nextNode == null) {//node 为最后一个节点
            last = prevNode;
        }else{
            nextNode.prev = node.prev;
        }
        size -= 1;
        return node;
        //end 去除中间一个节点
    }

    @Override
    public T getFirst() {
        Node<T> node = this.first;
        if (node == null)
            throw new NoSuchElementException();
        return node.item;
    }


    @Override
    public T getLast() {
        Node<T> node = this.last;
        if (node == null)
            throw new NoSuchElementException();
        return node.item;
    }

    @Override
    public T removeLast() {
        Node<T> node = this.last;
        if (node == null)
            throw new NoSuchElementException();
        return unlinkLast(node);
    }

    private T unlinkLast(Node<T> lastNode) {
        T t = lastNode.item;
        Node<T> lastprev = lastNode.prev;
        lastNode.item = null;
        lastNode.prev = null;
        this.last = lastprev; //更新last
        if (lastprev == null) //只有一元素
            this.first = null;
        else
            lastprev.next = null;
        this.size -= 1;
        return t;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node<T> node = first;
        while(first != null && node.next!= null){
            sb.append(node.item+",");
            node=node.next;
        }
        if (node != null) {
            sb.append(node.item);
        }       
        return sb.toString();
    }

    private static class Node<T> {
        T item;
        Node<T> next;
        Node<T> prev;

        Node(T thisObj,Node<T> prev, Node<T> nextNode) {
            this.item = thisObj;
            this.next = nextNode;
            this.prev = prev;
        }
    }
}

测试类

public class TestPLinkedList {

    public static void main(String[] args) {
        PLinkedListI<Integer> pLinkedListI = new PLinkedList<>();

        pLinkedListI.add(100);
        pLinkedListI.add(200);
        Integer integer3 = new Integer(300);
        pLinkedListI.add(integer3);

        System.out.println("get(1)"+pLinkedListI.get(1));
        System.out.println("get(2)"+pLinkedListI.get(2));
        System.out.println("before remove:"+pLinkedListI);
        pLinkedListI.remove(integer3);
        System.out.println("after remove :"+pLinkedListI);
        System.out.println("size : "+pLinkedListI.size());
        pLinkedListI.add(new Integer(400));
        System.out.println("before remove:"+pLinkedListI);
        pLinkedListI.remove(3);
        System.out.println("after remove :"+pLinkedListI);
    }
}

输出结果