用java创建一个自己的链表

public class LinkList<T> {
    private Node<T> head;  //头节点
    private int size;   //表示链表有多少个结点

    public LinkList(){
        this.head=null;
        this.size=0;
    }

    //判断链表是否为空
    public boolean IsEmpty(){ return this.size==0; }

    //向链表中添加节点(头插法)
    public void addHead(T data){
        //1.创建一个结点
        Node<T> node=new Node(data);
        //2.挂接
        node.next=this.head;
        this.head=node;
        //上述可以总结为：
        //this.head=new Node(data,this.head);
        //3.更新size
        this.size++;
    }

    //像链表中添加结点(尾插法)
    public void addTail(T data){
        Node<T> node=new Node(data);
        Node<T> CurNode=this.head;
        if(this.head==null){
            //如果插入时head结点为空则设置传进来的data所在的新节点为头节点
            this.head=node;
            this.size++;
            return;
        }
        while(CurNode.next!=null){
            CurNode=CurNode.next;
        }
        CurNode.next=node;
        size++;
    }

    //在任意位置添加
    public void add(int index,T data){
        //判断index是否有效
        if(index<0||index>=this.size){
            throw new IllegalArgumentException("index is invaild");
        }
        if(index==0){
            //如果索引为0,新头结点指向原本的头节点，data进入新head
            this.head=new Node(data,this.head);
            this.size++;
            return;
        }
        //创建一个结点
        Node<T> node=new Node(data);
        //找前驱结点，从头开始，一直到index-1
        Node pre=this.head;
        for (int i = 0; i < index; i++) {
            pre=pre.next;
        }
        //开始进行结点的连接
        node.next=pre.next;
        pre.next=node;
        this.size++;
    }

    //从链表中查找指定的元素是否存在
    public boolean contains(T data){
        // 遍历链表时，头节点不能动，所以要新建一个临时节点
        Node<T> curNode=this.head.next;
        while(curNode!=null){
            if(curNode.data.equals(data)){
                return true;
            }
            curNode=curNode.next;
        }
        return false;
    }

    //获取任意位置的元素
    public T get(int index){
        if(index<0||index>=this.size){
            throw new IllegalArgumentException("index is invaild");
        }
        Node<T> node=this.head;
        if(index==0){
            if(node!=null){
                return node.data;
            }
            else{
                return null;
            }
        }
        int n=0;
        while(node!=null&&n<index){
            node=node.next;
            n++;
        }
        return node.data;
    }

    //删除链表中某个索引的元素
    public void delete(int index){
        if(index==0){
            //直接让head指向原先head的下一个结点
            this.head=this.head.next;
            this.size--;
            return;
        }
        Node<T> node=this.head;
        for (int i = 0; i < index-1; i++) {
            node =node.next;
        }
        //遍历到index-1位置
        //保存一个delnode为待删除元素
        Node<T> DelNode=node.next;
        //node.next指向待删除元素的后面的一个元素
        node.next=DelNode.next;
        //把待删除元素设置为null
        DelNode.next=null;
        this.size--;
    }

    //获取第一个元素
    public T getfirst(){
        Node<T> curNode=this.head;
        if(curNode!=null) {
            return  curNode.data;
        }else {
            return null;
        }
    }
    //第二种方法：
    /*
    public Optional getfirst(){
        if(this.head==null){
            return Optional.empty();
        }
        return Optional.ofNullable(this.head.data);
    }
    */

    //移除第一个元素
    public void removefirst(){
        if(this.head!=null){
            this.head=this.head.next;
        }else{
            return;
        }
        this.size--;
    }

    //移除最后一个元素
    public void removelast(){
        if(this.head==null){
            return;
        }
        if(this.head.next==null){
            //如果头结点的下一个就是null，说明头节点就是尾结点
            this.head=null;
            size--;
            return;
        }
        Node<T> curNode=this.head;
        int len=0;
        //让指针指向size-2位置时把此位置的下一个位置也就是尾结点设为null
        while(len!=size-2) {
            curNode=curNode.next;
            len++;
        }
        curNode.next=null;
        this.size--;
    }

    //获取尾结点
    public T getlast(){
        if(this.head==null){
            return null;
        }
        Node<T> curNode=this.head;
        while(curNode.next!=null) {
            curNode=curNode.next;
        }
        return  curNode.data;
    }
    //第二种方法：
    /*
    public Optional getlast(){
        if(this.head.next==null){
            return Optional.empty();
        }
        Node<T> curNode=this.head;
        while(curNode.next!=null) {
            curNode=curNode.next;
        }
        return  Optional.of(curNode.data);
    }
    */

    //获取size
    public int getSize() {
        return size;
    }

    @Override
    public String toString() {
        //从this.head向后一直找
        //临时节点保存head
        Node<T> node=this.head;
        StringBuilder stringBuilder=new StringBuilder();
        while(node!=null){  //当node不为null时
            //向sb中添加node的data
            stringBuilder.append(node.data+"-->");
            //node指向下一个结点
            node=node.next;
        }
        stringBuilder.append("null");
        return stringBuilder.toString();
    }

    //使用内部类---创建节点

    class Node<T>{
        //结点内本身的数据
        T data;
        //指向下一个结点
        Node<T> next;
        //构造方法
        public Node(T data){
            this.data=data;
            this.next=null;
        }

        public Node(T data,Node next){
            this.data=data;
            this.next=next;
        }
    }
}