LinkedList的实现

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/starjingweij/article/details/80102258

import java.util.ConcurrentModificationException;
import java.util.NoSuchElementException;

public class MyLinkedList<AnyType> implements Iterable<AnyType> {
    private int theSize;
    private int modCount=0;
    private Node<AnyType> beginMarker;
    private Node<AnyType> endMarker;

    private static class Node<AnyType>{
        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;
        public Node(AnyType d, Node<AnyType> p, Node<AnyType> n){
            data = d;
            prev = p;
            next = n;
        }
    }
    public MyLinkedList(){
        doClear();
    }
    public void clear(){
        doClear();
    }
    public void doClear(){
        beginMarker = new Node<AnyType>(null,null,null);
        endMarker = new Node<AnyType>(null,beginMarker,null);
        beginMarker.next = endMarker;
    }
    public int size(){
        return theSize;
    }
    public boolean add(AnyType x){
        add(size(), x);
        return true;
    }
    public void add(int idx, AnyType x){
        addBefore(getNode(idx,0,size()-1),x);
    }
    public AnyType get(int idx){
        return getNode(idx).data;
    }
    public AnyType set(int idx, AnyType newVal){
        Node<AnyType> p = getNode(idx);
        AnyType oldVal = p.data;
        p.data = newVal;
        return oldVal;
    }
    public AnyType remove(int idx){
        return remove(getNode(idx));
    }
    public void addBefore(Node<AnyType> p,AnyType x){
        Node<AnyType> newNode = new Node<>(x, p.prev, p);
        newNode.prev.next = newNode;
        p.prev = newNode;
        theSize++;
        modCount++;
    }
    public AnyType remove(Node<AnyType> p){
        p.prev.next = p.next;
        p.next.prev = p.prev;
        theSize--;
        modCount++;
        return  p.data;
    }
    public Node<AnyType> getNode(int idx){
        return getNode(idx,0,size()-1);
    }
    public Node<AnyType> getNode(int idx, int lower, int upper){
        Node<AnyType> p;
        if(idx<lower||idx>upper){
            throw new IndexOutOfBoundsException();
        }
        if(idx<size()/2){
            p = beginMarker.next;
            for (int i = 0; i < idx; i++) {
                p = p.next;
            }
        }else{
            p = endMarker;
            for (int i = size(); i > idx ; i--) {
                p = p.prev;
            }
        }
        return p;
    }
    public java.util.Iterator<AnyType> iterator(){
        return new LinkedListIterator();
    }
    private class LinkedListIterator implements java.util.Iterator<AnyType>{
        private Node<AnyType> current = beginMarker.next;
        private int expectedModCount = modCount;
        private boolean okToRemove = false;
        public boolean hasNext(){
            return current  != endMarker;
        }
        @Override
        public AnyType next() {
            if(modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if(!hasNext())
                throw new NoSuchElementException();
            AnyType nextItem = current.data;
            current = current.next;
            okToRemove = true;
            return nextItem;
        }

        @Override
        public void remove() {
            if(modCount!=expectedModCount)
                throw new ConcurrentModificationException();
            if(!okToRemove)
                throw new IllegalStateException();
            MyLinkedList.this.remove(current.prev);
            expectedModCount++;
            okToRemove = false;
        }
    }
}