单链表java实现及相关操作（版本3）

   版本3将采用内部类的方式实现单链表，这样有两大好处，第一：封装；第二：更加贴合面向对象的思想。在链表类Link里面定义一个Node结点类，Node负责创建结点并且执行结点内部的相关操作，链表类负责执行对结点的相关操作。代码如下：

Link类:

import java.net.Inet4Address;
/**
 *这是一个链表类，结点类写在链表类的内部就更加贴合面向对象的思想（链表是由一个个结点组成的），这个类的作用是操作结点，
 *定义了操作结点的一些方法
 */
public class Link {
    
    private Node root;//设置头结点，头指针存放的下一个结点的地址
    private int count=0;//用于计算链表长度
    private int index=0;//定义的下标
    private String[] returnArray;//定义一个数组用来输出链表数据
    
    public String[] toArray() {
        if (this.root==null) {
            return null;
        }
        this.index=0;
        this.returnArray=new String[this.count];
        this.root.toArrayNode();
        return this.returnArray;
    }
    
    //删除方法
    public  void remove(String data) {
        if (this.contains(data)) {
            if (data.equals(this.root.data)) {
                this.root=this.root.next;
            }
        }else {
            this.root.next.removeNode(this.root, data);
            //此时下一个结点的上一个节点就是this。root
        }this.count--;
    }
    
    //修改方法
    public void set(int index,String data) {
        if(index>(this.count-1)||index<0) {
            return ;
        }
        this.index=0;
        this.root.setNode(index,data);
    }

    /**
     * *获取结点信息
     */
    public String get(int index) {
        if(index>(this.count-1)||index<0) {
            return null;
        }
        this.index=0;
        return this.root.getNode(index);
    }

    /**
     **设置指针结点方法
     */
    public void setIndex(int index) {
        this.index = index;
    }
    
    //返回链表长度
    public int size() {
        return this.count;
    }
    
    //判断链表是否为空
    public boolean isEmpty() {
        return this.count==0;
    }
    
    
    //调用结点类中的方法containsNode，根据传入的数据判断是否存在
    public boolean contains(String data) {
        if(data==null||this.root==null) {
            return false;
        }
        return this.root.containsNode(data);
    }
    
    public Link() {
    }
    //调用结点类中的方法增加结点

    //要注意增加结点这一块，是针对这一个结点的操作，所以只考虑这一个结点
    public void add(String data) {
        if(data==null) {
            return;
        }
        Node node=new Node(data);
        this.count++;//Node创建出来count就++
        
        if(this.root==null) {
            this.root=node;
        }else {
            this.root.addNode(node);
        }
        
    }
    

//******************************************************************
    /**
     **这是一个结点类，这个类的作用是创建一个个结点
     */
    private class Node{
        private String data;
        private Node next;
        
        //有参构造
        public Node(String data) {
            this.data = data;
        }
        
        //无参构造
        public Node() {
        }
    
        
        /**
         * 将链表数据变成数组输出
         */
        public void toArrayNode() {
            Link.this.returnArray[Link.this.index++]=this.data;
            if (this.next!=null) {
                this.next.toArrayNode();
            }
            
        }

        //第一次调用（link） previous=this.root;this=Link.root.next
        //第二次调用（Node） previous=this.root.next;this=Link.root.next.next.next
        public void removeNode (Node previous,String data) {
            if(this.data.equals(data)) {
                previous.next=this.next;
                
            }else {
                this.next.removeNode(previous, data);//this.next的父节点就是this
            }
            
        }
        
        /**
         * *设置结点信息方法
         */
        public void setNode(int index, String data) {
            if(Link.this.index++ ==index) {
                 this.data=data;
            }else {
                this.next.setNode(index,data);
                }
        }
        
        /**
         ** 获取结点信息方法
         */
        public String getNode(int index) {
            if(Link.this.index++ ==index) {
                return this.data;
            }else {
                return this.next.getNode(index);
                }
        }
        
        /**
         * *查找方法,判断数是否存在
         */
        public boolean containsNode(String data) {
            if(data.equals(this.data)) {
                return true;
            }else {
                if(this.next !=null) {
                    return this.next.containsNode(data);
                }else {
                    return false;
                }
            }
            
        }
        /**
         * 增加结点
         */
        //第一次调用（Link）:this=Link.root
        //第二次调用（Node）:this=Link.root.next

       //这里要重点理解指针，首先要明白指针是会移动的，当判断this.next是否为空的时候，指针已经移动到下一个结点了，next存放的是下一个结点的地址。
        public void addNode(Node node) {
            if(this.next==null) {
                this.next=node;
            }else {
                this.next.addNode(node);
            }
        }
        
        public String getData() {
            return data;
        }
        
        public void setData(String data) {
            this.data = data;
        }
    
        public Node getNext() {
            return next;
        }
        
        public void setNext(Node next) {
            this.next = next;
        }
    }
}

LinkeText类：

package lianbiaoDemo03;

public class LinkText {

    public static void main(String[] args) {
        Link link=new Link();
        link.add("葫芦娃1");
        link.add("葫芦娃2");
        link.add("葫芦娃3");
        link.add("葫芦娃4");
        link.add("葫芦娃5");
    //    System.out.println(link.size());
    //    System.out.println(link.isEmpty());
    //    System.out.println(link.contains("葫芦娃4"));
    //    System.out.println(link.get(1));
    //    link.set(1, "孙悟空");
    //    System.out.println(link.get(1));
    //    link.remove("葫芦娃3");
    //    System.out.println(link.get(2));
        String [] s=link.toArray();
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
    }
}