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

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

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