Java代码实现单链表存储

突然发现写多了TypeScript，使用this成了一个习惯哈哈哈哈哈~

import org.apache.poi.ss.formula.functions.T;

/**
 * @Author: jerrold
 * @Date: 2021/08/01
 * @Version 1.0
 * @description: 数组实现栈
 */
 
public class MyLinkedList<T> {
    
    

    //定义结点类
    private class Node{
    
    
        private T value;
        private Node next;
        public Node(T t,Node next){
    
    
            this.value = t;
            this.next = next;
        }
        public Node(T t){
    
    
            this(t,null);
        }
    }

    //头结点
    private Node head;
    //链表长度
    private int listSize;

    //初始化 initLinkedList
    public MyLinkedList(){
    
    
        this.head = null;
        this.listSize = 0;
    }

    /*返回线性表是否为空*/
    public boolean isEmpty() {
    
    
        return this.listSize == 0;//当前长度是否0
    }

    /*返回线性表的长度*/
    public int getListSize() {
    
    
        return this.listSize;
    }

    /*返回指定的第i个元素*/
    public T getElem(int i) throws Exception {
    
    
        if(i < 0 || i > this.listSize){
    
     //下标违规
            throw new Exception("ERROR");
        }
        Node curr = head.next;//拿到表头
        for (int j = 0; j < i; j++) {
    
     //遍历
            curr = curr.next;
        }
        return curr.value; //返回值
    }

    /*删除指定的第i个元素*/
    public void deleteElem(int i) throws Exception {
    
    
        if(i < 0 || i > this.listSize){
    
     
            throw new Exception("ERROR");
        }
        Node prev = head.next;  //指定元素前一个结点
        for (int j = 0; j < i-1; j++) {
    
    
            prev = prev.next;
        }
        Node pos = prev.next; //要删除的元素结点
        prev = pos.next; //将前节点指向后结点
        pos.next = null;
        this.listSize++;//链表长度加1
    }

    /*将指定i个元素设为t*/
    public void setElem(int i, T t) throws Exception {
    
    
        if(i < 0 || i > this.listSize){
    
     
            throw new Exception("ERROR");
        }
        Node curr = head.next;
        for (int j = 0; j < i; j++) {
    
     //遍历
            curr = curr.next; //当前结点
        }
        curr.value = t; //结点赋值
    }


    /*第i个元素位置插入指定t*/
    public void add(int i, T t) throws Exception {
    
    
        if(i == 0){
    
    
            this.addFirst(t);
            return;
        }
        if(i < 0 || i > this.listSize){
    
     
            throw new Exception("ERROR");
        }
        Node prev = head.next;
        for (int j = 0; j < i - 1; j++) {
    
    
            prev = prev.next;
        }
        Node curr = new Node(t); //创建要插入的结点
        curr.next = prev.next; //当前结点指向前结点的下一个结点
        prev.next = curr; //前结点指向当前结点
        this.listSize++;//链表长度加1
    }

    /*头部插入指定t*/
    public void addFirst(T t) {
    
    
       Node curr = new Node(t); //创建要插入的结点
       curr.next = this.head;//当前结点指向头结点
       this.head = curr; //头结点设为当前结点
       this.listSize++;//链表长度加1
    }

    /*尾部插入指定t*/
    public void addLast(T t){
    
    
        try {
    
    
            this.add(this.listSize, t);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

    /*移除指定元素t*/
    public void remove(T t) throws Exception {
    
    
        if (head == null){
    
    
            throw new Exception("ERROR");
        }
        Node prev = head;
        while (head.next != null){
    
     //有下一个结点同时当前结点值相等
            if (t.equals(head.next.value)){
    
    
                break;
            }
            prev = prev.next;
        }

        if (prev.next != null) {
    
    
            Node node = prev.next; //待删除结点
            prev.next = node.next; //待删除前结点指向待删除后结点
            node.next = null;
            this.listSize--;//链表长度减1
        }
    }
	
	/*清空链表*/
    public void clear(){
    
    
        this.head = null;//头结点置为null即可 当然也可以将全部结点置为null 加快GC回收
        this.listSize = 0;//长度置为0
	}
}