手写LinkedList

　　LinkedList是Java中最为简单也是最为常用的容器之一，那么它的内部构造是什么呢？其实LinkedList的底层实现就是链表，它的各种方法就是对链表进行的一系列操作，例如对链表节点的修改，删除，位移，对链表长度的获取等。我们可以手写一个LinkedList容器，以助我们更好的理解这个容器：

package LinkedList;

import java.util.Iterator;

public class MyLinkedList<E> implements Iterable<E> { //迭代器接口
    private Node first;
    private Node last;
    private int size;
    
    public int size() {
        return size;
    }
    
    public void rangeCheck(int index) {
        if(index<0||index>=size) {
            try {
                throw new MyException();
            } catch (MyException e) {
                e.printIndex();
            }
        }
    }
    
    public Node node(int index) {  //遍历,获得当前位序值
        if(index<=(size>>1)) {  //右移一位相当于除以2
            Node x = first;
            for(int i=0;i<index;++i)
                x=x.next;
            return x;
        }else {
            Node x = last;
            for(int i=size-1;i>index;--i)
                x=x.prev;
            return x;
        }
    }
    
    public boolean isEmpty(){
        return size==0;
    }
    
    public boolean contains(Object o) {
        return indexOf(o)>=0;
    }
    
    public int indexOf(Object o) {
        for(int i=0;i<size;++i) {
            if(node(i).object.equals(o))
                return i;
        }
        return -1;
    }
    
    private Node getNode(int index) {
        rangeCheck(index);
        return node(index);
    }
    
    @SuppressWarnings("unchecked")
    private E elementData(int index){
        return (E)getNode(index).object;
    }
    
    public E get(int index) {
        return elementData(index);
    }
    
    public E set(int index,E element) {
        rangeCheck(index);
        E oldValue = elementData(index);
        node(index).object = element;
        return oldValue;
    }
    
    public void add(E elemnt) {
        Node n = new Node();
        n.object = elemnt;
        if(first==null) {
            n.prev = null;
            n.next = null;
            first = last = n;
        }else {
            last.next = n;
            n.prev = last;
            n.next = null;
            last = n;
        }
        ++size;
    }
    
    public void add(int index,E element) {
        Node n = new Node();
        n.object = element;
        if(index>0) {
            Node temp = getNode(index-1);
            if(index!=size)
                temp.next.prev = n;
            n.next = temp.next;
            temp.next = n;
            n.prev = temp;
            if(index==size)
                last = n;
            ++size;
        }else if(index==0) {
            if(first==null) {
                n.prev = null;
                n.next = null;
                first = last = n;
            }else {
                n.prev = null;
                n.next = first;
                first.prev = n;
                first = n;
            }
            ++size;
        }else {
            try {
                throw new MyException();
            }catch(MyException e) {
                e.printIndex();
            }
        }
    }
    
    public void remove(int index) {
        Node temp =getNode(index);
        if(!(temp==first&&temp==last)) {
            if(temp==first) {
                temp.next.prev = null;
                first = temp.next;
            }else if(temp==last) {
                temp.prev.next = null;
                last = temp.prev;
            }else {
                temp.next.prev = temp.prev;
                temp.prev.next = temp.next;
            }
        }
        temp = null;
        --size;
    }
    
    public boolean remove(E element) {
        int i = 0;
        for(Node temp = first;temp!=null;temp=temp.next) {
            if(temp.object.equals(element)) {
                remove(i);
                return true;
            }
            ++i;
        }
        return false;
    }

    @Override
    public Iterator<E> iterator() {
        return new MyIter();
    }
    
    private class MyIter implements Iterator<E> {
        
        //计数器-->指针 游标
        private int cursor;
        private int lastRet = -1;

        //判断是否存在下一个
        @Override
        public boolean hasNext() {
            return cursor != size;
        }

        //返回游标当前位置，并把游标移到下一位置
        @SuppressWarnings("unchecked")
        @Override
        public E next() {
            if(!hasNext()) {
                try {
                    throw new MyException();
                } catch (MyException e) {
                    e.printnext();
                }
            }
            lastRet = cursor;
            return (E)node(cursor++).object;
        }
        
        @Override
        public void remove(){
            if(lastRet<0) {
                try {
                    throw new MyException();
                } catch (MyException e) {
                    e.printremove();
                }
            }
            MyLinkedList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
        }
    }
    
    public static void main(String[] args) {
        MyLinkedList<String> list = new MyLinkedList<>();
        list.add("ab");
        list.add("cde");
        list.add("fghi");
        list.add(3,"123");
        list.remove(0);
        //使用迭代器遍历
        for(Iterator<String> iter=list.iterator();iter.hasNext();){
            System.out.println(iter.next());
            //iter.remove();
        }
        System.out.println("----------------------------------");
        //使用增强for循环遍历
        for(String str:list){
            System.out.println(str);
        }
    }
}
class Node{
    Object object;
    Node prev;
    Node next;
}

package LinkedList;

public class MyException extends Exception{
    
    private static final long serialVersionUID = 1L;
    
    public MyException() {
        System.out.print("出现异常:");
    }
    
    public void printIndex() {
        System.out.println("索引范围越界!");
        System.exit(1);
    }
    
    public void printInit(){
        System.out.println("请重新初始化");
    }
    
    public void printnext() {
        System.out.println("游标越界!");
        System.exit(1);
    }
    
    public void printremove() {
        System.out.println("remove()只有在执行完next()后才能且只能执行一次!");
        System.exit(1);
    }
}