Java实现自定义链表

与C语言比起来，Java实现链表不用考虑复杂的指针关系，一切皆对象，所以相对来说比较简单。
PS：以下代码均采用递归实现，不考虑效率，旨在理解结构。

---

1.入门级

首先实现一个节点类：

package jimo.love;public class Node {    private String data;//数据    private Node next;//指向下一个节点    public Node(String data){        this.data = data;    }    public void setNext(Node next){        this.next = next;    }    public Node getNext(){        return this.next;    }    public String getData() {        return data;    }    public void setData(String data) {        this.data = data;    }}

然后在主方法中生成节点，完成连接关系，并打印出来，看代码有解释：

package jimo.love;public class Test {    public static void main(String[] args) {        //1.准备所有数据        Node head = new Node("头节点");        Node n1 = new Node("n1");        Node n2 = new Node("n2");        head.setNext(n1);        n1.setNext(n2);        //2.取出所有数据        //方法一：        Node curNode = head;        while(curNode!=null){            System.out.println(curNode.getData());            curNode = curNode.getNext();        }        //方法二,递归方式：        print(head);    }    //采用递归方式    public static void print(Node curNode){        if(curNode==null){            return ;        }        System.out.println(curNode.getData());        print(curNode.getNext());    }}

代码中用了两种方式取数据，看执行结果：

可以看到Main方法里写的东西太多了，还要设置数据，输出数据。
但面向对象的思想让我们不需要关注太多的东西和具体的实现。
所以我们需要一个工具类，我们只关注存数据和取数据，并不关心怎么存，怎么取。

2.中级

我们增加一个Link类用于业务操作：

public class Link {    private Node head;    public void add(String data){        Node newNode = new Node(data);        if(this.head==null){            this.head = newNode;//头节点        }else{            //头插法//          newNode.setNext(this.head.getNext());//          this.head.setNext(newNode);            //尾插法            this.head.addNode(newNode);        }    }    public void print(){        if(this.head!=null){            this.head.printNode();        }    }}

其中的addNode和printNode方法来自Node类：

//递归添加节点    public void addNode(Node node){        if(this.next==null){            this.next = node;        }else{            this.next.addNode(node);        }    }    //递归打印节点    public void printNode(){        System.out.println(this.data);        if(this.next!=null){            this.next.printNode();        }    }

在主函数里：

        Link link = new Link();        link.add("1");        link.add("2");        link.add("3");        link.print();

3.高级

在可用链表中，你不可能直接操作节点类吧,像这样：

Node n = new Node("n");

所以，我们要让Node类只能被Link类使用，具体方法是将Node类声明为Link类的私有内部类：

4.终极

一个链表不可能只有一个add方法吧，接下来就完善方法：

1.size():取得元素个数

在Link类中声明属性count：

private int count = 0;

在add函数里自加：

this.count++;//增加完就++

返回size：

    //取得数量    public int size(){        return this.count;    }

测试：

        Link link = new Link();        link.add("1");        link.add("2");        link.add("3");        link.add(null);        System.out.println(link.size());

可以看到我添加了一个null元素，但也添加进去了，添不添加取决于自己，我这里不让添加，所以在add函数里修改：

        if(null==data){            return ;        }

2.isEmpty():判断链表是否为空：

    public boolean isEmpty(){        return 0==this.count;    }

3.contains(data):判断数据是否存在：
在Link类中：

    //根据内容查询数据    public boolean contains(String data){        if(null==data||null==this.head){            return false;        }else{            return this.head.containNode(data);        }    }

在Node类中：

        public boolean containNode(String data){            if(data.equals(this.data)){                return true;            }else{                if(null!=this.next){                    return this.next.containNode(data);                }else{                    return false;//递归结束条件                }            }        }

4.get(int index):根据索引查找数据：

在Link类添加属性：

private int index = 0;

在Node类添加方法：

        public String getNode(int index){            //注意Link.this.index            if(Link.this.index++==index){                return this.data;            }else{                return this.next.getNode(index);            }        }

注意：Link.this.index是内部类获得外部类属性的方法。

在Link类添加方法：

    //通过索引查找内容    public String get(int index){        if(index >= this.count){            return null;        }        this.index = 0;//每次从头向后查询        return this.head.getNode(index);    }

注意：查找时索引从0开始，当然可以改成从1开始。

5.set(int index,data):根据索引修改内容：

其实和查找一样，只是操作不同方而已：

在Node类：

        public void setNode(int index,String data){            if(Link.this.index++==index){                this.data = data;            }else{                this.next.setNode(index, data);            }        }

在Link类：

    //根据索引修改内容    public void set(int index,String data){        if(index >= this.count){            return ;        }else{            this.head.setNode(index,data);        }    }

6.remove(data)：删除一个元素：

这也是相对来说最复杂的部分，不过也很简单。

在Node类：

        //对非根节点的删除        public void removeNode(Node preNode,String data){            if(data.equals(this.data)){                preNode.next = this.next;            }else{                this.next.removeNode(this, data);            }        }

在Link类，要判断是否是根节点：

    //删除    public void remove(String data){        if(this.contains(data)){            //删除根节点            if(data.equals(this.head.data)){                this.head = this.head.next;            }else{  //非根节点                this.head.next.removeNode(this.head, data);            }            this.count--;//别忘了        }    }

7.toArray():转化成数组：

在Link类添加一个属性：private String[] retArray;

在Node类：

        public void toArrayNode(){            Link.this.retArray[Link.this.index++] = this.data;            if(null!=this.next){                this.next.toArrayNode();            }        }

在Link类：

    public String[] toArray(){        if(null == this.head){            return null;        }        this.index = 0;        this.retArray = new String[this.count];        this.head.toArrayNode();        return this.retArray;    }

5.总结

以上代码不能够用于实战开发，只是为了理解引用关系的传递，后续的改进可以添加更多的方法，不用递归，加入泛型，做出和List一样的效果。