java实现链表（模拟LinkedList）

 众所周知，链表是由一个个节点连接在一起，这里我们就先创建一个节点类，为了达到模拟效果，我们选择建一个Node的静态内部类。

我们要想模拟LinkedList，就得先了解LinkedList的类包含的方法：

 add(Object）   dd(int,Object)   addFirst   addLast   get(int index)   remove    getIndex  removeFirst  removeLast等

以及LinkedList 所实现的接口：

    

我们为了要使用foreach语句遍历，就必须实现Iterable接口。附上代码：

import java.util.Iterator;
public class MyLinkedList<T> implements Iterable<T>{
    private Node<T> first;//指向第一个节点的工作指针
    private Node<T> current;//指向最后一个节点的工作指针
    private int size=0;//统计链表长度
    private static class Node<T>{
        T data;
        Node<T> next;
    }
    //获取长度
    public int size(){
        return size;
    }
    //添加节点
    public void add(T data){
        Node<T> newNode=new Node<T>();
        newNode.data=data;
        
        if(first==null){
            first=newNode;
            current=newNode;
            size++;
            return;
        }
        current.next=newNode;
        current=newNode;
        size++;
    }
    //插入第一个位置
    public void addFirst(T data){
        Node<T> newNode=new Node<T>();
        newNode.data=data;
        
        if(first==null){
            first=newNode;
            current=newNode;
            size++;
            return;
        }
        newNode.next=first;
        first=newNode;
        size++;
    }
    public void addLast(T data){
        add(data);
    }
    //根据索引添加节点
    public void add(int index,T data){
        Node<T> newNode=new Node<T>();
        newNode.data=data;        
        
        Node node=getNode(index);//指向指定索引之前的节点        
        
        if(node==null){
            addFirst(data);
            return;
        }
        newNode.next=node.next;
        node.next=newNode;
        size++;
    }
    /**
     * 得到指定索引的数据
     * @param index
     * @return 数据
     */
    public T get(int index){
        return getNode(index).next.data;
    }
    /**
     * 得到指定索引的前一个节点
     * @param index
     * @return
     */
    private Node<T> getNode(int index) {
        Node<T> node=null;
        if(index==0){
            //插入到第一个
            return null;
        }
        if(index<size){
            //插入中间
            node=first;
            for(int i=1;i<index;i++){
                node=node.next;
            }
            return node;
        }
        return current;
    }
    /**
     * 迭代器
     */
    public Iterator<T> iterator(){
        return new Iterator<T>() {
            Node<T> cur;
            @Override
            public boolean hasNext() {
                if(cur==null && first!=null){
                    cur=first;
                    return true;
                }
                if(cur.next!=null){
                    cur=cur.next;
                    return true;
                }
                return false;
            }
            @Override
            public T next() {
                return cur.data;
            }
        };
    }
    /**
     * 移除数据
     * @param data
     */
    public void remove(T data){
        //查找数据的索引
        int index=getIndex(data);
        remove(index);
    }
    /**
     * 通过数据查找第一次出现的索引
     * @param data
     * @return
     */
    private int getIndex(T data) {
        Node node=first;
        for(int i=0;i<size;i++){
            if(node.data.equals(data)){
                return i;
            }
            node=node.next;
        }
        return -1;
    }
    /**
     * 移除指定索引的数据
     * @param index
     */
    public void remove(int index){
        Node prev=getNode(index);
        Node node=getNode(index+1);
        prev.next=node.next;
        size--;
    }
    /**
     * 移除第一个
     */
    public void removeFirst(){
        first=first.next;
        size--;
    }
    /**
     * 移除最后一个
     */
    public void removeLast(){
        //查找倒数第二个节点
        Node node=getNode(size-1);
        node.next=null;
        current=node;
        size--;
    }
    /**
     * 修改指定索引的数据
     * @param index
     * @param newData
     */
    public void set(int index,T newData){
        //得到指定索引节点
        Node node=getNode(index+1);
        if(node==null){
            node=first;
        }
        //修改节点上的数据
        node.data=newData;
    }
}

到这里我们基本模拟了LinkedList类的所有方法，我们赶紧来测试下:

public class Demo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        MyLinkedList<String> list=new MyLinkedList<String>();
        list.add("AAA");
        list.add("BBB");
        list.add("CCC");
        list.addFirst("DDD");
        list.addLast("EEE");
        list.add(2,"FFF");
        
        for(String s:list){
            System.out.println(s);
        }
        String s=list.get(2);
        System.out.println("下标为2的元素:"+s);
        
        list.set(2, "TEST");
        System.out.println("Size:"+list.size());
        list.removeFirst();
        list.removeLast();
        list.remove(2);
        System.out.println("------------------");
        for(String st:list){
            System.out.println(st);
        }
    }
}

这里我们附上效果图: