简化 java.util.LinkedList 类的源码

谁借莪１个温暖的怀抱￠ 2022-12-10 14:31 115阅读 0赞

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { 
    
        @java.io.Serial
        private static final long serialVersionUID = 876323262645176354L; // 序列化版本号
        transient int size = 0;     // 当前元素个数0
        transient Node<E> first;    // 指向第一个节点数据
        transient Node<E> last;     // 指向最后一个节点
    
    
        /** * 存储数据的 * Node数据结构 */
        private static class Node<E> { 
            E item;
            Node<E> next;
            Node<E> prev;
    
            Node(Node<E> prev, E element, Node<E> next) { 
                this.item = element;
                this.next = next;
                this.prev = prev;
            }
        }
        /** * LinkedList构造方法 */
        public LinkedList() { }                          // 构造一个空集合
        public LinkedList(Collection<? extends E> c) { } // 构造一个带有c集合所有元素的集合
    
    
        /** * 添加元素 */
        public void addFirst(E e) { }            // 将节点e加入作为第一个节点
        public void addLast(E e) {  }            // 将节点e加入作为尾节点
        public boolean add(E e) { }              // 添加元素，会加入到链表末尾
        public boolean offer(E e) { }            // 添加元素，调用的是add(e);就是上面一个方法
        public void add(int index, E element) { }// index位置加入元素element
        public boolean addAll(Collection<? extends E> c) { }             // 添加集合元素
        public boolean addAll(int index, Collection<? extends E> c) { }  // 指定位置后添加元素
        public boolean offerFirst(E e) { }       // 添加e成为首元素
        public boolean offerLast(E e) { }        // 添加e成为尾元素元素
        public void push(E e) { }                // 添加e并成为首元素
        /** * 移除元素 */
        public E removeFirst() { }               // 移除首元素
        public E removeLast() { }                // 移除最后一个节点
        public E pollFirst() { }                 // 返回并移除首元素
        public E pollLast() { }                  // 返回并移除尾元素
        public E remove() { }                    // 移除首元素
        public E pop() { }                       // 移除首元素并返回首元素
        public E poll() { }                      // 返回首元素并从链表中剔除首元素，或者返回null
        public boolean remove(Object o) { }      // 移除元素o，如果成功返回true，失败（说明不存在）返回false
        public E remove(int index) { }           // 移除index位置的元素
        public boolean removeFirstOccurrence(Object o) { }   // 从头开始找元素o，并移除元素o
        public boolean removeLastOccurrence(Object o) { }    // 从尾往前找元素o，并移除元素
        /** * 修改元素 */
        public E set(int index, E element) { }   // 替换index索引元素存的内容
        /** * 查询元素 */
        public E getFirst() { }                  // 获取第一个节点
        public E getLast() { }                   // 获取最后一个节点
        public E peek() { }                      // 返回表头元素或者null
        public E element() { }                   // 返回表头元素，如果为null则抛异常，不会返回null元素
        public E peekLast() { }                  // 返回尾元素，可以返回null
        public E get(int index) { }              // 获得index索引下的元素
        public int indexOf(Object o) { }         // 从首元素往后找，返回元素o的索引值，如果不存在则返回-1
        public int lastIndexOf(Object o) { }     // 从尾元素往前找，返回元素索引
        public boolean contains(Object o) { }    // 是否包含o
    
    
        /** * 其它对集合操作的方法 * 链表转数组 * 集合大小、清空集合、克隆集合、迭代器 */
        public Object[] toArray() { }            // 链表转数组，不带泛型
        public <T> T[] toArray(T[] a) { }        // 链表转数组，传入泛型
        public int size() { }                    // 返回链表长度
        public void clear() { }                  // 清除所有元素
        private LinkedList<E> superClone() { }   // 克隆一个LinkedList对象
        public Object clone() { }                // 将所有元素都克隆一份，并返回
        public Spliterator<E> spliterator() { }  // 迭代器，允许并行处理
        public ListIterator<E> listIterator(int index) { } // 迭代器
    
        /** * 后面的可以不用看，主要需要掌握前面对外提供的方法 * * 不对外使用的方法 */
        E unlink(Node<E> x) { }                  // 移除节点x
        Node<E> node(int index) { }              // 返回index下的节点
        void linkLast(E e) { }                   // 链接到最后一个节点上
        void linkBefore(E e, Node<E> succ) { }   // 链接到succ节点的上一个节点
        private void linkFirst(E e) { }          // 链接到第一个节点上
        private E unlinkFirst(Node<E> f) { }     // 移除第一个节点
        private E unlinkLast(Node<E> l) { }      // 移除最后一个节点
        private boolean isElementIndex(int index) { }    // 判断index是否在链表长度内
        private boolean isPositionIndex(int index) { }   // 判断index是否是正向索引
        private String outOfBoundsMsg(int index) { }     // 返回超出索引范围的提示字符串："Index: "+index+", Size: "+size;
        private void checkElementIndex(int index) { }    // 检查元素索引index是否在链表长度以内，不是则抛异常
        private void checkPositionIndex(int index) { }   // 检查正向索引
        /** * 序列化 */
        @java.io.Serial
        private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { }
        /** * 反序列化 */
        @SuppressWarnings("unchecked")
        @java.io.Serial
        private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { }
    
    
        public Iterator<E> descendingIterator() { 
            return new DescendingIterator();
        }
    
        private class DescendingIterator implements Iterator<E> { 
            private final ListItr itr = new ListItr(size());
            public boolean hasNext() { } // 是否有下一个元素
            public E next() { }          // 返回下一个元素
            public void remove() { }     // 移除当前迭代器返回的元素
        }
        private class ListItr implements ListIterator<E> { 
            private Node<E> lastReturned;           // 上一个元素节点
            private Node<E> next;                   // 下一个节点元素
            private int nextIndex;                  // 上一个元素索引值
            private int expectedModCount = modCount;// 并发修改异常计数
            ListItr(int index) { }                   // 构造器
            public void add(E e) { }                 // 添加
            public void remove() { }                 // 删除
            public void set(E e) { }                 // 修改
            public boolean hasNext() { }             // 判断是否有下一个元素
            public E next() { }                      // 返回下一个元素
            public boolean hasPrevious() { }         // 是否有上一个值
            public E previous() { }                  // 返回上一个元素
            public int nextIndex() { }               // 下一个元素的索引值
            public int previousIndex() { }           // 上一个元素的索引值
            public void forEachRemaining(Consumer<? super E> action) { } // 遍历迭代器剩余元素
            final void checkForComodification() { }                      // 检查并发修改异常
        }
        
        static final class LLSpliterator<E> implements Spliterator<E> { 
            static final int BATCH_UNIT = 1 << 10;  // batch array size increment
            static final int MAX_BATCH = 1 << 25;   // max batch array size;
            final LinkedList<E> list; // null OK unless traversed
            Node<E> current;      // current node; null until initialized
            int est;              // size estimate; -1 until first needed
            int expectedModCount; // initialized when est set
            int batch;            // batch size for splits
            LLSpliterator(LinkedList<E> list, int est, int expectedModCount) { } // 构造方法
            public void forEachRemaining(Consumer<? super E> action) { } // 遍历剩余元素
            public boolean tryAdvance(Consumer<? super E> action) { }    // 尝试获取剩余元素，如果没有剩余元素返回false
            final int getEst() { }
            public long estimateSize() { }
            public Spliterator<E> trySplit() { }
            public int characteristics() { }
        }
        
    }