共同学习Java源代码--数据结构--LinkedList类(八)

    public Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }
这个方法返回一个倒叙Iterator，倒叙Iterator在下面：

 
    private class DescendingIterator implements Iterator<E> {
        private final ListItr itr = new ListItr(size());

        生成一个ListItr，传入size方法返回值作为长度。

        public boolean hasNext() {

            return itr.hasPrevious();

        }

        hasNext就是调用hasPrevious，判断有没有上一个

        public E next() {
            return itr.previous();
        }
        public void remove() {
            itr.remove();
        }
    }
其他方法不列举了 就是倒叙遍历。

    @SuppressWarnings("unchecked")
    private LinkedList<E> superClone() {
        try {
            return (LinkedList<E>) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }

    }

这个方法是调用父类的克隆方法克隆一个链表。

public Object clone() {
        LinkedList<E> clone = superClone();
        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;
        for (Node<E> x = first; x != null; x = x.next)
            clone.add(x.item);
        return clone;
    }

这个方法是浅克隆一个链表。

首先调用上一个superClone方法返回一个链表克隆体。首先将链表的大部分属性置空或归零。然后克隆体一个一个添加元素。最后返回克隆体。

    public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        return result;
    }

这个方法是将链表转换成数组的方法。

首先构建一个Object数组，长度为链表长度。

然后遍历链表将元素添加进去。最后返回Object数组。

    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;
        if (a.length > size)
            a[size] = null;
        return a;
    }

这个方法是将链表转换成数组的方法，但传入一个泛型数组参数。

先判断参数长度如果小于链表长度，参数重新指向一个新的数组，类型为泛型，长度为链表长度，这里使用了反射机制。

然后和上面的方法大同小异。最后判断一下参数指向的数组的长度大于链表长度，就将参数指向的数组的链表长度位置空。

最后返回参数指向的数组。

   private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();
        // Write out size
        s.writeInt(size);
        // Write out all elements in the proper order.
        for (Node<E> x = first; x != null; x = x.next)
            s.writeObject(x.item);
    }

这个方式是在序列化时对外输出数据的方法。

需要传入一个Object输出流。首先调用输出流的默认输出对象方法，将类型信息输出。

然后输出链表长度，最后依次输出链表所有元素。

    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();
        // Read in size
        int size = s.readInt();
        // Read in all elements in the proper order.
        for (int i = 0; i < size; i++)
            linkLast((E)s.readObject());
    }

这个方法是在序列化时对内输入数据的方法，和输出方法大同小异，不多说了。

LinkedList的绝大部分内容都写完了，剩下的是1.8新特性，这个暂时先不考虑。