单向链表实现元素存取容器

基于链表结构存取元素的方法API定义：

package com.bjsxt;

/**
 * @Author:Dai
 * @Date:2022/4/23 基于链表结构存取元素的方法API定义
 */
public interface MyList<E> {

    void add(E element);

    E get(int index);

    int size();

    E remove(int index);

}

基于单向链表实现元素存取的容器：

package com.bjsxt;

/**
 * @Author:Dai
 * @Date:2022/4/23 基于单向链表实现元素存取的容器
 */
public class MySinglyLinkedList<E> implements MyList<E> {

    /**
     * 定义单向链表中的节点对象
     */
    class Node<E> {
        private E item;//存储元素
        private Node next;//存储下一个节点对象的地址

        //构造方法
        Node(E item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    private Node head;//存放链表中的头节点
    private int size;//记录元素个数

    /**
     * 向链表中添加元素
     *
     * @param element
     */
    @Override
    public void add(E element) {
        //创建节点
        Node<E> node = new Node<>(element, null);
        //找到尾节点
        Node tail = getTail();
        //节点挂接
        if (tail == null) this.head = node;
        else tail.next = node;
        //记录元素个数
        this.size++;
    }

    /**
     * 找尾节点
     */
    private Node getTail() {
        //判断头节点是否存在
        if (this.head == null) {
            return null;
        }
        //查找尾节点
        Node prev = this.head;
        while (true) {
            if (prev.next == null) break;
            prev = prev.next;//移动指针，指向下一个节点
        }
        return prev;
    }

    /**
     * 根据元素位置获取元素
     *
     * @param index
     * @return
     */
    @Override
    public E get(int index) {
        //校验Index的合法性
        this.checkIndex(index);
        //根据位置获取指定节点
        Node<E> node = this.getNode(index);
        //将该节点的元素返回
        return node.item;
    }

    /**
     * 校验Index
     */
    private void checkIndex(int index) {
        if (!(index >= 0 && index < this.size))
            throw new IndexOutOfBoundsException("Index：" + index + "Size：" + this.size);
    }

    /**
     * 根据位置获取节点
     */
    private Node getNode(int index) {
        Node<E> prev = this.head;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        return prev;
    }

    /**
     * 获取元素个数
     *
     * @return
     */
    @Override
    public int size() {
        return this.size;
    }

    /**
     * 根据元素位置删除元素
     *
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        //校验Index合法性
        this.checkIndex(index);
        //根据位置获取指定节点对象
        Node<E> node = this.getNode(index);
        //通过节点对象获取元素
        E item = node.item;
        //将该节点对象从单向链表中移除
            //判断当前删除的节点是否为头节点
        if (this.head == node) {
            this.head = node.next;
        } else {
            Node<E> temp = this.head;
            for (int i = 0; i < index - 1; i++) {
                temp = temp.next;
            }
            temp.next = node.next;
        }
        node.next = null;
        //元素个数的记录
        this.size--;
        return item;
    }

}