linkedList方法的源码理解2

接上篇，剩余方法的理解，欢迎各位大佬指点

 @Override
    public Iterator<T> descendingIterator() {//这个方法，没具体写
        /**
         * 就是调用迭代器的hasPrevious和previous
         * 这两个方法的作用就是逆序输出
         * 集体可以看源码或者老师今天上午写的代码
         */
        Iterator<T> it = (Iterator<T>) iterator();
        while(it.hasPrevious()){
            return (Iterator<T>) it.previous();
        }
        return (Iterator<T>) it;
    }

    @Override
    public T element() {//检索但不删除此类表的头
        return getFirst();//直接调用getFist方法
    }

    @Override
    public T get(int index) {
        /**
         * 先判定下标是狗越界，越界就抛异常
         */
        if (index < 0 || index >=size) {
            throw new ArrayIndexOutOfBoundsException("index out of bounds:" + index);
        }
        return node(index).t;//直接调用node方法，获取对应下标所对应的值
    }

    @Override
    public T getFirst() {//获取头元素
       Node<T> x = root;//声明一个节点l，并赋值为头节点
        if (x == null) {//先判定这个节点是否为空，如果为空抛异常
            throw new NoSuchElementException();
        }
        return x.t;//不为空就直接返回这个节点的值
    }

    @Override
    public T getLast() {//获取尾元素
        Node<T> x = root;//声明一个节点l，并赋值为尾节点
        if (x == null) {//先判定这个节点是否为空，如果为空抛异常
            throw new NoSuchElementException();
        }
        return x.t;//不为空就直接返回这个节点的值
    }


    @Override
    public Iterator<T> listIterator(int index) {
        /**
         * 先判定下标是狗越界，越界就抛异常
         */
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("index out of bounds:" + index);
        }
        /**
         *不具体写了，迭代器我很垃圾
         * 就是从这个下标开始，然后用迭代器去遍历
         * 然后依次返回各个节点的值，直到遍历结束
         */
        Iterator<T> it = (Iterator<T>) iterator();//假装是从index开始
        while(it.hasNext()){
            return (Iterator<T>) it.next();
        }
        return (Iterator<T>) it;
    }

    @Override
    public boolean offer(T t) {//将指定的元素添加为此列表的尾部（最后一个元素）。
        return add(t);//直接调用add方法（原理一样）
    }

    @Override
    public boolean offerFirst(T t) {//在此列表的头插入指定的元素。
        addFirst(t);//直接调用addFirst方法
        return true;//添加成功返回true
    }

    @Override
    public boolean offerLast(T t) {//在该列表的末尾插入指定的元素。
        addLast(t);//直接调用addLast方法
        return true;//添加成功返回true
    }

    @Override
    public T peek() {//检索但不删除此列表的头（第一个元素）。
        Node<T> f = root;//声明一个节点f，并赋值为头节点
        return (f == null) ? null : f.t;//判断f这个节点是否为空，为空则返回null，不为空返回f的值t
    }

    @Override
    public T peekFirst() {//检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
        Node<T> f = root;//声明一个节点f，并赋值为头节点
        return (f == null) ? null : f.t;//判断f这个节点是否为空，为空则返回null，不为空返回f的值t
    }

    @Override
    public T peekLast() {//检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
        Node<T> f = curr;//声明一个节点f，并赋值为尾节点
        return (f == null) ? null : f.t;//判断f这个节点是否为空，为空则返回null，不为空返回f的值t
    }

    @Override
    public T poll() {//检索并删除此列表的头（第一个元素）。
        Node<T> f = root;//声明一个节点f，并赋值为头节点
        //判断f这个节点是否为空，为空则返回null，不为空调用removefirst方法删除头节点
        return (f == null) ? null :removeFirst();
    }

    @Override
    public T pollFirst() {//检索并删除此列表的第一个元素，如果此列表为空，则返回 null 。
        Node<T> f = root;//声明一个节点f，并赋值为头节点
        //判断f这个节点是否为空，为空则返回null，不为空，调用removefirst方法删除头节点
        return (f == null) ? null :removeFirst();
    }

    @Override
    public T pollLast() {//检索并删除此列表的最后一个元素，如果此列表为空，则返回 null 。
        Node<T> f = curr;//声明一个节点f，并赋值为尾节点
        //判断f这个节点是否为空，为空则返回null，不为空，调用removeLast方法删除尾节点
        return (f == null) ? null :removeLast();
    }

    @Override
    public T pop() {//从此列表表示的堆栈中弹出一个元素。 换句话说，删除并返回此列表的第一个元素。
        return removeFirst();//调用removefirst方法删除头节点
    }

    @Override
    public void push(T t) {//将元素推送到由此列表表示的堆栈上。 换句话说，在该列表的前面插入元素。
        addFirst(t);//调用addFirst方法增加头节点
    }

    @Override
    public T remove() {//检索并删除此列表的头（第一个元素）。
        Node<T> f = root;//声明一个节点f，并赋值为头节点
        if (f == null) {//先判定节点是否为空，为空就抛异常
            throw new NoSuchElementException();
        }
        f.next.prve = null;//将f.next.prve（表示第二个节点的头指针）置空
        root = f.next;//将原链表第二个节点赋值给头节点（或者说第二个节点变为头节点）
        f.t = null;//将f的值置空
        f.next=null;//将f的尾指针置空
        size--;
        return f.t;//返回f的值
    }

    @Override
    //删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。 返回从列表中删除的元素。
    public T remove(int index) {
        /**
         * 先判定下标是狗越界，越界就抛异常
         */
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("index out of bounds:" + index);
        }
        Node<T> x = node(index);//声明一个节点x，并调用node方法，将x的附值为需要下标在原链表对应的值
        if (index == 0) {//第一种情况，下标是头
            remove();//直接调用在remove()方法
        } else if (index == size-1) {//第二中情况，指定下标是尾
            removeLast();//直接调用removeLast的方法（
        } else {//第三种情况，在中间删除元素
            x.prve.next = x.next;//在删除之后，原链表对应下标的前一个节点的尾指针应当指向原链表对应下标的下一个节点
            x.next.prve = x.prve;//在删除之后，原链表对应下标的下一个节点的头指针应当指向原链表对应下标的前一个节点
            x.prve = null;//当前节点的头指针置空
            x.t = null;//当前节点的值置空
            x.next = null;//当前节点的尾指针置空
            size--;
        }
        return x.t;//返回对应下标节点的值
    }

    @Override
    public boolean remove(Object t) {
        int index = indexOf(t);//先调用indexOf方法找到所需要找的元素的下标
        /**
         * indexOf()方法的返回值：
         * 如果为-1.则证明所找元素在这个链表不存在
         * 如果为0.则证明所找元素在这个链表中处于头节点的位置
         * 如果为size-1.则证明所找元素在这个链表中处于尾节点的位置
         * 如果index>0 && index<size-1，则证明所找元素在这个链表中处于中间节点的位置
         */
        if (index==-1){
            return false;
        }else{
           remove(index); //其余的情况调用 remove（int index）方法即可
        }
        return false;
    }

    @Override
    public T removeFirst() {//从此列表中删除并返回第一个元素。
        return remove();//直接调用remove（）方法；
    }

    @Override
    //删除此列表中指定元素的第一个出现（从头到尾遍历列表时）。 如果列表不包含该元素，则它不会更改。
    public boolean removeFirstOccurrence(Object t) {
        return remove(t);//直接调用remove（t）方法
    }

    @Override
    public T removeLast() {//删除链表中最后一个元素
        Node<T> x = curr;//声明一个节点x，并赋值为尾节点
        if (x== null){  //先判定这个节点是否为空，不为空则
            throw new NoSuchElementException();
        }
        curr = x.prve; //将尾指针的指向更改为，x节点的前一个节点
        x.prve.next = null; //将x节点的前一个节点的尾指针置空
        x.prve = null;  //将x节点的头指针置空
        x.t = null; //将x节点的值置空
        size--;
        return null;
    }

    @Override
    //删除此列表中指定元素的最后一次出现（从头到尾遍历列表时）。 如果列表不包含该元素，则它不会更改。
    public boolean removeLastOccurrence(Object t) {
        /**
         * LastindexOf()方法的返回值：
         * 如果为-1.则证明所找元素在这个链表不存在
         * 如果为0.则证明所找元素在这个链表中处于头节点的位置,且这个元素只出现一次
         * 如果为size-1.则证明所找元素在这个链表中处于尾节点的位置,且这个元素只出现一次
         * 如果index>0 && index<size-1，则证明所找元素在这个链表中处于中间节点的位置
         */
       int index = LastIndexOf(t);
        if (index==-1){
            return false;
        }else{
            remove(index); //其余的情况调用 remove（int index）方法即可
        }
        return false;
    }

    @Override
    public T set(int index, T t) {
        /**
         * 先判定下标是狗越界，越界就抛异常
         */
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("index out of bounds:" + index);
        }
        Node<T> x = node(index); //声明一个节点，调用node方法得到对应下标的值
        T oldVal = x.t; //将得到原本下标对应的值赋给oldVal
        x.t = t;    //将原本下标对应的值更改为t
        return oldVal;  //返回oldVal
    }


    //这个暂时没搞懂，下次更新
    @Override
    public Iterator<T> spliterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        Object[] arr = new Object[size];//声明一个新数组arr,数组的长度为链表中元素的个数size
        int i = 0;
        //使用for循环，依次用头开始将链表中各个节点的值赋给数组
        for (Node<T> x = root; x != null; x = x.next)
            arr[i++] = x.t;
        return arr; //返回这个数组
    }

    @Override
    public <T1> T1[] toArray(T1[] a) {
        //先判定数组的长的是否小于size
        if (a.length < size) {
            /**
             * 如果小于，表明这个数组不能完全存下指定元素
             *   将为指定数组的运行时类型和此列表的大小分配一个新数组。
             */
            a = (T1[]) java.lang.reflect.Array.newInstance(
                    a.getClass().getComponentType(), size);
        }
        int i = 0;
        Object[] result = a;//声明一个新数组a,数组的长度为链表中元素的个数size
        //使用for循环，依次用头开始将链表中各个节点的值赋给数组
        for (Node<T> x = root; x != null; x = x.next) {
            result[i++] = x.t;
        }
        //如果大于，则紧跟在列表末尾的数组中的元素将设置为null
        if (a.length > size) {
            a[size] = null;
        }
        return a;//返回这个数组
    }

}