超详细！java实现链表

Node<T>结点类

public class Node<T>{
    //结点类
    /*
    数据域：data
    存取域：next
     */

    public T data;//数据域
    public Node<T> next;//地址域  这里是装的是下一个结点的地址，所以类型是结点类型

    //有参构造
    public Node(T data, Node<T> next){
        this.data = data;
        this.next = next;
    }

    //无参构造，手动调用有参构造赋空值
    public Node(){
        this(null,null);
     }

    @Override
    public String toString() {
        return this.data.toString();
    }
}

SinglyList<T>类

public class SinglyList<T> {
    /*
      单链表要要实现的功能：是否为空、清空、增、删、改、查、链表长度
     */
        public Node<T> head;//声明头结点
        public Node<T> rear;//声明尾结点

        private int count;//计算结点的长度

    //无参构造方法
    public SinglyList(){
        this.head = new Node<T>();
       //System.out.println("head赋值前："+head.next);
    }

    public SinglyList(T [] values){
        this();//调用无参构造，创建空头节点
        rear = this.head;//最初，头指针和尾指针指向位置相同
       // System.out.println("read赋值前："+rear.next);
        for (int i = 0; i < values.length; i++) {
            if(values[i] != null){
                rear.next = new Node<T>(values[i],null);
                rear = rear.next;
                this.count++;
            }

        }

//        System.out.println("head赋值后："+head.next);
//        System.out.println("rear赋值后："+rear.next);


    }

    /*
    public boolean isEmpty()
    return:为空返回真，不为空返回假
     */
    public boolean isEmpty(){
        if(this.head == null ){
            return true;
        }
        return false;
    }

    /*
    public void clear()
    将头节点和尾结点置空
     */
    public void clear(){
        this.head.data = null;
        this.head.next = null;
        this.rear.data = null;
        this.rear.next = null;
    }

    /*
    public Node<T> insert(int location,T e)
    插入元素
    location:要插入的位置
    e:要插入的元素
    return:你要插入新节点的地址
     */
   public Node<T> insert(int location,T e){

       //location小于 0 则插到头节点的后边
       //location大于count 则插到尾结点
       //提高了容错率


       Node<T> p = this.head;
        if( e == null ){
            return null;
        }
        for(int j = 0; p.next != null && j <location;j++){p = p.next;}

        /*
        这里很重要
        new Node<T>(e,p.next);  这是将要插入的元素，生成一个新结点
        Node<T>(e,p.next) 这里的p.next 是你要插入的位置，本来的元素的地址
        也就是说，你把你要插入那个位置原本的元素的地址，作为自己的next，你这个新
        结点就连接上了你要插入那个位置原本的元素以及后边的元素

        p.next = new Node<T>(e,p.next); 这里被赋值的p.next
        就是你要插入那个位置原本的元素前一个元素
        这里你就把你要插入的结点的地址，放到了它next里边
         */
        p.next = new Node<T>(e,p.next);

        return p.next;
   }

   /*
    public T delete(T e)
    删除链表中的指定元素
    e:要删除的元素
    return:返回要删除的元素
    */
    public T delete(T e){
       Node<T> p = this.head;

       //如果要删除的元素为空，则返回空
       if(e == null){
           return null;
       }

       //寻找元素
        // 如果找到了元素，我们要将e的next交给它的前一个元素的next
       while(p.next.data != e){p = p.next;} //这里我们找的e的前一个结点
        p.next = p.next.next;
        this.count--;//还得链表数量减去一个

       return e;
    }

    /*
    public T set(int index,T e)
    index:要修改元素的索引
    e:要替换元素的值
    return:被修改之前元素的值
     */
    public T set(int index,T e){
        //保证在有效的范围之内
        if(index >= 0&& index <= this.count){
            Node<T> p = this.head;
            //找到的是第i - 1个元素
            for (int i = 0; i < index && p!=null; i++) {
                p = p.next;
            }
            T previousElement = p.next.data;//保存要删除前的元素
            p.next.data = e;

            return previousElement;//返回被替代之前的元素
        }

        return null;
    }


    /*
    public Node<T> search(T key)
    寻找元素
    key:要找的元素
    return:返回找到元素的地址，没找到就返回Null
     */
    public Node<T> search(T key){
        Node<T> p = this.head;
        for (int i = 0; i < this.count; i++) {
            if(p.data == key){
                return  p;
            }
            p = p.next;
        }
        return null;

    }


    @Override
    public String toString() {
        String str = this.getClass().getName() + "(";
        Node<T> p = this.head.next;
        for (int i = 0; i < this.count; i++) {
            if(p !=null){
                str += p.data;
            }
           if(p.next != null){
               p = p.next;
           }
        }
        return  str +")";
    }
}

Test测试类

public class Test {
    public static void main(String[] args) {
        String []str = {"a","b","c","d","e","f","g","h"};
        SinglyList<String> singlyList = new SinglyList<String>(str);
        System.out.println(singlyList.toString());
        Node p = singlyList.search("g");
        System.out.println(p.data);

    }

}