2021-02-20

为了加深对LinkedList集合的理解，本着好记性不如烂笔头的思想，我手写了一个简易的LinkedList集合，能够实现简单的链表的增删改查。

还有一个自己写的subList方法

package cn.edu.***.manager;

import java.util.Collection;
import java.util.NoSuchElementException;

/**
 * 双向链表
 *
 * @param <E>
 */
public class LinkedList<E> {
    /**
     * LinkedList私有类 Node<E>节点
     *
      * @param <E>
     */
    private static class Node<E> {
        /**
         * 链表每个节点存放的元素
         */
        E item;

        /**
         * 链表指向下一个元素位置的后继指针
         */
        Node<E> next;

        /**
         * 链表指向上一个元素位置的前趋指针
         */
        Node<E> prev;

        /**
         * 链表节点的构造方法
         *
         * @param prev 前趋指针
         * @param element 节点元素
         * @param next 后继指针
         */
        Node(Node<E> prev, E element, Node<E> next) {
            this.prev = prev;
            this.item = element;
            this.next = next;
        }
    }

    /**
     * 链表的修改次数，保证链表的线程安全
     */
    protected transient int modCount = 0;

    /**
     * 链表有效元素个数
     */
    transient int size = 0;

    /**
     * 头指针
     */
    Node<E> first;

    /**
     * 尾指针
     */
    Node<E> last;

    /**
     * 无参构造方法
     */
    public LinkedList() {

    }

    /**
     * 在创建链表对象时添加一个Collection集合的子类存入链表中
     *
     * @param e Collection子类
     */
    public LinkedList(Collection<? extends E> e) {
        this();
        addAll(e);
    }

    /**
     * 添加方法，添加一个集合子类到链表中
     *
     * @param c Collection集合子类
     * @return 添加成功返回true
     */
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

    /**
     * 在指定下标添加一个集合子类到链表中
     *
     * @param index 指定的下标
     * @param c 指定的Collection集合子类
     * @return 添加成功返回true
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }

        for (Object o : a) {
            E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
    }

    /**
     * 添加一个元素到链表头节点（头插法）
     *
     * @param e 泛型约束的类型
     */
    public void addFirst(E e) {
        linkFirst(e);
    }

    /**
     * 添加一个元素到链表尾
     *
     * @param e 泛型约束的指定元素
     */
    public void addLast(E e) {
        linkLast(e);
    }

    /**
     * 在链表中添加指定元素
     *
     * @param e 泛型约束的指定元素
     */
    public void add(E e) {
        linkLast(e);
    }

    /**
     * 在指定下标添加指定元素
     *
     * @param index 指定的下标位置
     * @param e 泛型约束的指定元素
     */
    public void add(int index, E e) {
        checkPositionIndex(index);

        if (index == size) {
            linkLast(e);
        } else {
            linkBefore(e, node(index));
        }
    }

    /**
     * 删除指定下标元素
     *
     * @param index 指定下标位置
     * @return 返回删除的元素内容
     */
    public E remove(int index) {
        checkElementIndex(index);

        return unlink(node(index));
    }

    /**
     * 删除链表头
     *
     * @return 返回删除的元素内容
     */
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null) {
            throw new NoSuchElementException();
        }
        return unLinkFirst(f);
    }

    /**
     * 删除链表尾
     *
     * @return 返回删除的元素内容
     */
    public E removeLast() {
        final Node<E> l = last;
        if (l == null) {
            throw new NoSuchElementException();
        }
        return unLinkLast(l);
    }

    /**
     * 找到指定元素并删除成功返回true，找不到返回false
     *
     * @param obj Object类型，要找的指定元素
     * @return 找到并删除返回true，找不到返回false
     */
    public boolean remove(Object obj) {
        if (obj == null) {
            for (Node<E> i = first; i != null; i = i.next) {
                if (i.item == null) {
                    unlink(i);
                    return true;
                }
            }
        } else {
            for (Node<E> i = first; i != null; i = i.next) {
                if (obj.equals(i.item)) {
                    unlink(i);
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * 修改指定下标的元素内容尾指定元素
     *
     * @param index 修改元素的指定下标
     * @param e 泛型E约束，替换的指定元素内容
     * @return 返回被修改的元素内容
     */
    public E set(int index, E e) {
        checkElementIndex(index);

        Node<E> node = node(index);
        E oldValue = node.item;
        node.item = e;

        return oldValue;
    }

    /**
     * 有效元素个数
     *
     * @return int类型返回值，返回有效元素个数
     */
    public int size() {
        return size;
    }

    /**
     * 根据指定下标获取指定元素
     *
     * @param index int类型，需要获取元素的指定下标
     * @return 返回获得的元素
     */
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    /**
     * 获得链表头元素
     *
     * @return 返回链表头的元素内容
     */
    public E getFirst() {
        final Node<E> f = first;
        if (f == null) {
            throw new NoSuchElementException();
        }
        return f.item;
    }

    /**
     * 获得链表尾元素
     *
     * @return 返回链表尾元素内容
     */
    public E getLast() {
        final Node<E> l = last;
        if (l == null) {
            throw new NoSuchElementException();
        }
        return l.item;
    }

    /**
     * 查找指定元素第一次出现的下标位置
     *
     * @param obj Object类型，查找的指定元素
     * @return int类型返回值，返回下标位置，未找到返回-1
     */
    public int indexOf(Object obj) {
        int index = 0;
        if (obj == null) {
            for (Node<E> i = first; i != null; i = i.next) {
                if (i.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> i = first; i != null; i = i.next) {
                if (obj.equals(i.item))
                    return index;
                index++;
            }
        }

        return -1;
    }

    /**
     * 查找指定元素在链表中最后一次出现的位置
     *
     * @param obj Object类型，查找的指定元素
     * @return int类型返回值，返回元素最后一次出现的下标位置
     */
    public int lastIndexOf(Object obj) {
        int index = size;
        if (obj == null) {
            for (Node<E> i = last; i != null; i = i.prev) {
                index--;
                if (i.item == null)
                    return index;
            }
        } else {
            for (Node<E> i = last; i != null; i = i.prev) {
                index--;
                if (obj.equals(i.item))
                    return index;
            }
        }

        return -1;
    }

    /**
     * 查询指定元素是否为当前链表内的元素
     *
     * @param obj Object类型，指定的查找元素
     * @return boolean类型返回值，链表中存在指定元素返回true
     */
    public boolean contains(Object obj) {
        return indexOf(obj) !=  0; // 感觉indexOf(obj) > 0;更合适点
    }

    /**
     * 将链表元素封装为Object类型数组返回
     *
     * @return 返回一个Object类型数组
     */
    public Object[] toArray() {
        Object[] result = new Object[size];

        int i = 0;
        for (Node<E> index = first; index != null; index = index.next)
            result[i++] = index.item;

        return result;
    }

    // 以自己的思路写的写的subList方法
    /**
     * 返回当前链表的子集
     *
     * @param start 子集的首元素，当前集合的指定下标
     * @param end 子集的尾元素，当前集合的指定下标
     * @return 返回一个LinkedList对象
     */
    public LinkedList<E> subList(int start, int end) {
        LinkedList<E> list = new LinkedList<>();

        Node<E> node = node(start);
        for(int i = start ; node != null && i <= end; i++) {
            list.add(node.item);
            node = node.next;
        }

        return list;
    }

    /**
     * 将最后一个节点从链表中解除连接，返回最后一个节点的元素内容
     */
    private E unLinkLast(Node<E> l) {
        final E element = l.item;
        final Node<E> prev = l.prev;

        if (prev == null)
            first = null;
        else
            prev.next = null;

        size--;
        modCount++;
        return element;
    }

    /**
     * 将第一个节点从链表中解除连接，返回最后一个节点的元素内容
     */
    private E unLinkFirst(Node<E> f) {
        final E element = f.item;
        final Node<E> next = f.next;

        f.item = null;
        f.next = null;

        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;

        return element;

    }

    /**
     * 将指定节点从链表中解除连接
     */
    private E unlink(Node<E> node) {
        final E element = node.item;
        final Node<E> prev = node.prev;
        final Node<E> next = node.next;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            node.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            node.next = null;
        }

        node.item = null;
        size--;
        modCount++;
        return element;
    }

    /**
     * 查找指定下标的元素（包括前趋地址与后继地址）
     */
    private Node<E> node(int index) {
        if (index < (size >> 1)) {
            Node<E> temp = first;
            for (int i = 0; i < index; i++)
                temp = temp.next;
            return temp;
        } else {
            Node<E> temp = last;
            for (int i = size - 1; i > index; i--)
                temp = temp.prev;
            return temp;
        }
    }

    /**
     * 检查指定下标作为元素下标是否越界，如果参数size时，会造成下标越界
     */
    private void checkElementIndex(int index) {
        if (isElementIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    /**
     * 检查指定下标是否越界，范围包含size
     */
    private void checkPositionIndex(int index) {
        if (isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 元素下标是否越界的条件判断语句
     */
    private boolean isElementIndex(int index) {
        return index < 0 || index >= size;
    }

    /**
     * 是否越界的条件判断语句
     */
    private boolean isPositionIndex(int index) {
        return index < 0 || index > size;
    }

    /**
     * 下标越界的提示信息
     */
    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }

    /**
     * 头插法，如果链表为空，则头指针，尾指针都为空，
     * 如果链表不为空，则之前的头指针前趋指向新节点
     */
    private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);

        first = newNode;

        if (f == null) {
            last = newNode;
        } else {
            f.prev = newNode;
        }

        size++;
        modCount++;
    }

    /**
     * 在指定节点前插入新的节点
     * 若指定节点为头节点，则新的头节点尾新创建的节点
     * 若指定节点为中间节点，则将原有节点的前一个节点后继指针指向新节点
     */
    private void linkBefore(E e, Node<E> succ) {
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;

        if (pred == null) {
            first = newNode;
        } else {
            pred.next = newNode;
        }

        size++;
        modCount++;
    }

    /**
     * 尾插法，如果链表为空，则头指针，尾指针都为空，
     * 如果链表不为空，则之前的尾指针后继指向新节点
     */
    private void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;

        if (l == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }

        size++;
        modCount++;
    }

}