A:添加功能
boolean add(E e):向集合中添加一個(gè)元素
void add(int index, E element):在指定位置添加元素
boolean addAll(Collection<? extends E> c)：向集合中添加一個(gè)集合的元素。

B:刪除功能
void clear()：刪除集合中的所有元素
E remove(int index)：根據(jù)指定索引刪除元素，并把刪除的元素返回
boolean remove(Object o)：從集合中刪除指定的元素
boolean removeAll(Collection<?> c):從集合中刪除一個(gè)指定的集合元素。

C:修改功能
E set(int index, E element):把指定索引位置的元素修改為指定的值，返回修改前的值。

D:獲取功能
E get(int index)：獲取指定位置的元素
Iterator iterator():就是用來獲取集合中每一個(gè)元素。

E:判斷功能
boolean isEmpty()：判斷集合是否為空。
boolean contains(Object o)：判斷集合中是否存在指定的元素。
boolean containsAll(Collection<?> c)：判斷集合中是否存在指定的一個(gè)集合中的元素。

F:長(zhǎng)度功能
int size():獲取集合中的元素個(gè)數(shù)

G:把集合轉(zhuǎn)換成數(shù)組
Object[] toArray():把集合變成數(shù)組。

public class ArrayListTest {
    public static void main(String[] agrs){
        //創(chuàng)建ArrayList集合：
        List<String> list = new ArrayList<String>();
        System.out.println("ArrayList集合初始化容量："+list.size());
		// ArrayList集合初始化容量：0
        
        //添加功能：
        list.add("Hello");
        list.add("world");
        list.add(2,"!");
        System.out.println("ArrayList當(dāng)前容量："+list.size());
        // ArrayList當(dāng)前容量：3

        //修改功能：
        list.set(0,"my");
        list.set(1,"name");
        System.out.println("ArrayList當(dāng)前內(nèi)容："+list.toString());
        // ArrayList當(dāng)前內(nèi)容：[my, name, !]

        //獲取功能：
        String element = list.get(0);
        System.out.println(element);
        // my

        //迭代器遍歷集合：(ArrayList實(shí)際的跌倒器是Itr對(duì)象)
        Iterator<String> iterator =  list.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        /**  
        	my
            name
            !
        */

        //for循環(huán)迭代集合：
        for(String str:list){
            System.out.println(str);
        }
        /**  
        	my
            name
            !
        */

        //判斷功能：
        boolean isEmpty = list.isEmpty();
        boolean isContain = list.contains("my");

        //長(zhǎng)度功能：
        int size = list.size();

        //把集合轉(zhuǎn)換成數(shù)組：
        String[] strArray = list.toArray(new String[]{});

        //刪除功能：
        list.remove(0);
        list.remove("world");
        list.clear();
        System.out.println("ArrayList當(dāng)前容量："+list.size());
        // ArrayList當(dāng)前容量：0
    }
}

public class LinkedListTest {
    public static void main(String[] agrs){
        List<String> linkedList = new LinkedList<String>();
        System.out.println("LinkedList初始容量："+linkedList.size());
        // LinkedList初始容量：0

        //添加功能：
        linkedList.add("my");
        linkedList.add("name");
        linkedList.add("is");
        linkedList.add("jiaboyan");
        System.out.println("LinkedList當(dāng)前容量："+ linkedList.size());
        // LinkedList當(dāng)前容量：4

        //修改功能:
        linkedList.set(0,"hello");
        linkedList.set(1,"world");
        System.out.println("LinkedList當(dāng)前內(nèi)容："+ linkedList.toString());
        // LinkedList當(dāng)前內(nèi)容：[hello, world, is, jiaboyan]

        //獲取功能：
        String element = linkedList.get(0);
        System.out.println(element);
        // hello

        //遍歷集合：(LinkedList實(shí)際的迭代器是ListItr對(duì)象)
        Iterator<String> iterator =  linkedList.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        /**
        	hello
            world
            is
            jiaboyan
        */
        
        //for循環(huán)迭代集合：
        for(String str:linkedList){
            System.out.println(str);
        }
        /**
        	hello
            world
            is
            jiaboyan
        */

        //判斷功能：
        boolean isEmpty = linkedList.isEmpty();
        boolean isContains = linkedList.contains("jiaboyan");

        //長(zhǎng)度功能：
        int size = linkedList.size();

        //刪除功能：
        linkedList.remove(0);
        linkedList.remove("jiaboyan");
        linkedList.clear();
        System.out.println("LinkedList當(dāng)前容量：" + linkedList.size());
        // LinkedList當(dāng)前容量：0
    }
}

public class ListTest{
    // 迭代次數(shù)
    public static int ITERATION_NUM = 100000;

    public static void main(String[] args) {
        try{
            insertPerformanceCompare();
        }catch (Exception e){}
    }

    //新增性能比較：
    public static void insertPerformanceCompare() throws InterruptedException {
        Thread.sleep(5000);

        System.out.println("LinkedList新增測(cè)試開始");
        long start = System.nanoTime();
        List<Integer> linkedList = new LinkedList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            linkedList.add(x);
        }
        long end = System.nanoTime();
        System.out.println(end - start);

        System.out.println("ArrayList新增測(cè)試開始");
        start = System.nanoTime();
        List<Integer> arrayList = new ArrayList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            arrayList.add(x);
        }
        end = System.nanoTime();
        System.out.println(end - start);
    }
}

public class ListTest {
    //迭代次數(shù)，集合大?。?
    public static int ITERATION_NUM = 100000;

    public static void main(String[] agrs) {
       try{
            getPerformanceCompare();
        }catch (Exception e){}
    }

    //獲取性能比較：
    public static void getPerformanceCompare()throws InterruptedException {
        Thread.sleep(5000);

        //填充ArrayList集合：
        List<Integer> arrayList = new ArrayList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            arrayList.add(x);
        }

        //填充LinkedList集合：
        List<Integer> linkedList = new LinkedList<Integer>();
        for (int x = 0; x < ITERATION_NUM; x++) {
            linkedList.add(x);
        }

        //創(chuàng)建隨機(jī)數(shù)對(duì)象：
        Random random = new Random();

        System.out.println("LinkedList獲取測(cè)試開始");
        long start = System.nanoTime();
        for (int x = 0; x < ITERATION_NUM; x++) {
            int j = random.nextInt(x + 1);
            int k = linkedList.get(j);
        }
        long end = System.nanoTime();
        System.out.println(end - start);

        System.out.println("ArrayList獲取測(cè)試開始");
        start = System.nanoTime();
        for (int x = 0; x < ITERATION_NUM; x++) {
            int j = random.nextInt(x + 1);
            int k = arrayList.get(j);
        }
        end = System.nanoTime();
        System.out.println(end - start);
    }
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    //實(shí)現(xiàn)Serializable接口，生成的序列版本號(hào)：
    private static final long serialVersionUID = 8683452581122892189L;

    //ArrayList初始容量大?。涸跓o參構(gòu)造中不使用了
    private static final int DEFAULT_CAPACITY = 10;

    //空數(shù)組對(duì)象：初始化中默認(rèn)賦值給elementData
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //ArrayList中實(shí)際存儲(chǔ)元素的數(shù)組：
    private transient Object[] elementData;

    //集合實(shí)際存儲(chǔ)元素長(zhǎng)度：
    private int size;

    //ArrayList有參構(gòu)造：容量大小
    public ArrayList(int initialCapacity) {
        //即父類構(gòu)造：protected AbstractList() {}空方法
        super();
        //如果傳遞的初始容量小于0 ，拋出異常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        //初始化數(shù)據(jù)：創(chuàng)建Object數(shù)組
        this.elementData = new Object[initialCapacity];
    }

    //ArrayList無參構(gòu)造：
    public ArrayList() {
        //即父類構(gòu)造：protected AbstractList() {}空方法
        super();
        //初始化數(shù)組：空數(shù)組，容量為0
        this.elementData = EMPTY_ELEMENTDATA;
    }

    //ArrayList有參構(gòu)造：Java集合
    public ArrayList(Collection<? extends E> c) {
        //將集合轉(zhuǎn)換為數(shù)組：
        elementData = c.toArray();
        //設(shè)置數(shù)組的長(zhǎng)度：
        size = elementData.length;
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }
}

//添加元素e
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    //將對(duì)應(yīng)角標(biāo)下的元素賦值為e：
    elementData[size++] = e;
    return true;
}
//得到最小擴(kuò)容量
private void ensureCapacityInternal(int minCapacity) {
    //如果此時(shí)ArrayList是空數(shù)組,則將最小擴(kuò)容大小設(shè)置為10：
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //判斷是否需要擴(kuò)容：
    ensureExplicitCapacity(minCapacity);
}
//判斷是否需要擴(kuò)容
private void ensureExplicitCapacity(int minCapacity) {
    //操作數(shù)+1
    modCount++;
    //判斷最小擴(kuò)容容量-數(shù)組大小是否大于0：
    if (minCapacity - elementData.length > 0)
        //擴(kuò)容：
        grow(minCapacity);
}
//ArrayList動(dòng)態(tài)擴(kuò)容的核心方法:
private void grow(int minCapacity) {
    //獲取現(xiàn)有數(shù)組大小：
    int oldCapacity = elementData.length;
    //位運(yùn)算，得到新的數(shù)組容量大小，為原有的1.5倍：
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果新擴(kuò)容的大小依舊小于傳入的容量值，那么將傳入的值設(shè)為新容器大小：
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    //如果新容器大小，大于ArrayList最大長(zhǎng)度：
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //計(jì)算出最大容量值：
        newCapacity = hugeCapacity(minCapacity);
    //數(shù)組復(fù)制：
    elementData = Arrays.copyOf(elementData, newCapacity);
}
// 計(jì)算ArrayList最大容量：
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    //如果新的容量大于MAX_ARRAY_SIZE。將會(huì)調(diào)用hugeCapacity將int的最大值賦給newCapacity:
    return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

//在ArrayList的移除index位置的元素
public E remove(int index) {
    //檢查角標(biāo)是否合法：不合法拋異常
    rangeCheck(index);
    //操作數(shù)+1：
    modCount++;
    //獲取當(dāng)前角標(biāo)的value:
    E oldValue = elementData(index);
    //獲取需要?jiǎng)h除元素 到最后一個(gè)元素的長(zhǎng)度，也就是刪除元素后，后續(xù)元素移動(dòng)的個(gè)數(shù)；
    int numMoved = size - index - 1;
    //如果移動(dòng)元素個(gè)數(shù)大于0 ，也就是說刪除的不是最后一個(gè)元素：
    if (numMoved > 0)
        // 將elementData數(shù)組index+1位置開始拷貝到elementData從index開始的空間
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //size減1，并將最后一個(gè)元素置為null
    elementData[--size] = null;
    //返回被刪除的元素：
    return oldValue;
}

//在ArrayList的移除對(duì)象為O的元素，不返回被刪除的元素：
public boolean remove(Object o) {
    //如果o==null，則遍歷集合，判斷哪個(gè)元素為null：
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                //快速刪除，和前面的remove（index）一樣的邏輯
                fastRemove(index);
                return true;
            }
    } else {
        //同理：
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

//快速刪除：
private void fastRemove(int index) {
    //操作數(shù)+1
    modCount++;
    //獲取需要?jiǎng)h除元素 到最后一個(gè)元素的長(zhǎng)度，也就是刪除元素后，后續(xù)元素移動(dòng)的個(gè)數(shù)；
    int numMoved = size - index - 1;
    //如果移動(dòng)元素個(gè)數(shù)大于0 ，也就是說刪除的不是最后一個(gè)元素：
    if (numMoved > 0)
        // 將elementData數(shù)組index+1位置開始拷貝到elementData從index開始的空間
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //size減1，并將最后一個(gè)元素置為null
    elementData[--size] = null;
}

//設(shè)置index位置的元素值了element，返回該位置的之前的值
public E set(int index, E element) {
    //檢查index是否合法：判斷index是否大于size
    rangeCheck(index);
    //獲取該index原來的元素：
    E oldValue = elementData(index);
    //替換成新的元素：
    elementData[index] = element;
    //返回舊的元素：
    return oldValue;
}

//獲取index位置的元素
public E get(int index) {
    //檢查index是否合法：
    rangeCheck(index);
    //獲取元素：
    return elementData(index);
}
//獲取數(shù)組index位置的元素：返回時(shí)類型轉(zhuǎn)換
E elementData(int index) {
    return (E) elementData[index];
}

protected transient int modCount = 0;

//返回一個(gè)Iterator對(duì)象，Itr為ArrayList的一個(gè)內(nèi)部類，其實(shí)現(xiàn)了Iterator<E>接口
public Iterator<E> iterator() {
    return new java.util.ArrayList.Itr();
}

//Itr實(shí)現(xiàn)了Iterator接口，是ArrayList集合的迭代器對(duì)象
private class Itr implements Iterator<E> {
    //類似游標(biāo)，指向迭代器下一個(gè)值的位置
    int cursor; 

    //迭代器最后一次取出的元素的位置。
    int lastRet = -1; 

    //Itr初始化時(shí)候ArrayList的modCount的值。
    int expectedModCount = modCount;

    //利用游標(biāo)，與size之前的比較，判斷迭代器是否還有下一個(gè)元素
    public boolean hasNext() {
        return cursor != size;
    }

    //迭代器獲取下一個(gè)元素：
    public E next() {
        //檢查modCount是否改變：
        checkForComodification();
        int i = cursor;
        //游標(biāo)不會(huì)大于等于集合的長(zhǎng)度：
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = java.util.ArrayList.this.elementData;
        //游標(biāo)不會(huì)大于集合中數(shù)組的長(zhǎng)度：
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        //游標(biāo)+1
        cursor = i + 1;
        //取出元素：
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        //檢查modCount是否改變：防止并發(fā)操作集合
        checkForComodification();
        try {
            //刪除這個(gè)元素：
            java.util.ArrayList.this.remove(lastRet);
            //刪除后，重置游標(biāo)，和當(dāng)前指向元素的角標(biāo) lastRet
            cursor = lastRet;
            lastRet = -1;
            //重置expectedModCount：
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    //并發(fā)檢查：
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

private transient Object[] elementData;

//序列化寫入：
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
    int expectedModCount = modCount;
    s.defaultWriteObject();
    s.writeInt(size);
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

// 序列化讀?。?
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;
    s.defaultReadObject();
    s.readInt();
    if (size > 0) {
        ensureCapacityInternal(size);
        Object[] a = elementData;
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

public class LinkedList<E>
        extends AbstractSequentialList<E>
        implements List<E>, Deque<E>, Cloneable, java.io.Serializable {

    //LinkedList的元素個(gè)數(shù)：
    transient int size = 0;

    //LinkedList的頭結(jié)點(diǎn)：Node內(nèi)部類
    transient java.util.LinkedList.Node<E> first;

    //LinkedList尾結(jié)點(diǎn)：Node內(nèi)部類
    transient java.util.LinkedList.Node<E> last;

    //空實(shí)現(xiàn)：頭尾結(jié)點(diǎn)均為null，鏈表不存在
    public LinkedList() {
    }

    //調(diào)用添加方法：
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    //節(jié)點(diǎn)的數(shù)據(jù)結(jié)構(gòu)，包含前后節(jié)點(diǎn)的引用和當(dāng)前節(jié)點(diǎn)
    private static class Node<E> {
        //結(jié)點(diǎn)元素：
        E item;
        //結(jié)點(diǎn)后指針
        java.util.LinkedList.Node<E> next;
        //結(jié)點(diǎn)前指針
        java.util.LinkedList.Node<E> prev;

        Node(java.util.LinkedList.Node<E> prev, E element, java.util.LinkedList.Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
}

//添加元素：添加到最后一個(gè)結(jié)點(diǎn)；
public boolean add(E e) {
    linkLast(e);
    return true;
}

//last節(jié)點(diǎn)插入新元素：
void linkLast(E e) {
    //將尾結(jié)點(diǎn)賦值個(gè)體L:
    final java.util.LinkedList.Node<E> l = last;
    //創(chuàng)建新的結(jié)點(diǎn)，將新節(jié)點(diǎn)的前指針指向l:
    final java.util.LinkedList.Node<E> newNode = new java.util.LinkedList.Node<>(l, e, null);
    //新節(jié)點(diǎn)置為尾結(jié)點(diǎn)：
    last = newNode;
    //如果尾結(jié)點(diǎn)l為null：則是空集合新插入
    if (l == null)
        //頭結(jié)點(diǎn)也置為 新節(jié)點(diǎn)：
        first = newNode;
    else
        //l節(jié)點(diǎn)的后指針指向新節(jié)點(diǎn)：
        l.next = newNode;
    //長(zhǎng)度+1
    size++;
    //操作數(shù)+1
    modCount++;
}

//向?qū)?yīng)角標(biāo)添加元素：
public void add(int index, E element) {
    //檢查傳入的角標(biāo) 是否正確：
    checkPositionIndex(index);
    //如果插入角標(biāo)==集合長(zhǎng)度，則插入到集合的最后面：
    if (index == size)
        linkLast(element);
    else
        //插入到對(duì)應(yīng)角標(biāo)的位置：獲取此角標(biāo)下的元素先
        linkBefore(element, node(index));
}
//在succ前插入 新元素e：
void linkBefore(E e, java.util.LinkedList.Node<E> succ) {
    //獲取被插入元素succ的前指針元素：
    final java.util.LinkedList.Node<E> pred = succ.prev;
    //創(chuàng)建新增元素節(jié)點(diǎn)，前指針 和 后指針分別指向?qū)?yīng)元素：
    final java.util.LinkedList.Node<E> newNode = new java.util.LinkedList.Node<>(pred, e, succ);
    succ.prev = newNode;
    //succ的前指針元素可能為null，為null的話說明succ是頭結(jié)點(diǎn)，則把新建立的結(jié)點(diǎn)置為頭結(jié)點(diǎn)：
    if (pred == null)
        first = newNode;
    else
        //succ前指針不為null，則將前指針的結(jié)點(diǎn)的后指針指向新節(jié)點(diǎn)：
        pred.next = newNode;
    //長(zhǎng)度+1
    size++;
    //操作數(shù)+1
    modCount++;
}

//刪除對(duì)應(yīng)角標(biāo)的元素：
public E remove(int index) {
    checkElementIndex(index);
    //node()方法通過角標(biāo)獲取對(duì)應(yīng)的元素，在后面介紹
    return unlink(node(index));
}

//刪除LinkedList中的元素，可以刪除為null的元素，逐個(gè)遍歷LinkedList的元素，重復(fù)元素只刪除第一個(gè)：
public boolean remove(Object o) {
    //如果刪除元素為null：
    if (o == null) {
        for (java.util.LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        //如果刪除元素不為null：
        for (java.util.LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

//移除LinkedList結(jié)點(diǎn)：remove()方法中調(diào)用
E unlink(java.util.LinkedList.Node<E> x) {
    //獲取被刪除結(jié)點(diǎn)的元素E：
    final E element = x.item;
    //獲取被刪除元素的后指針結(jié)點(diǎn)：
    final java.util.LinkedList.Node<E> next = x.next;
    //獲取被刪除元素的前指針結(jié)點(diǎn)：
    final java.util.LinkedList.Node<E> prev = x.prev;

    //被刪除結(jié)點(diǎn)的 前結(jié)點(diǎn)為null的話：
    if (prev == null) {
        //將后指針指向的結(jié)點(diǎn)置為頭結(jié)點(diǎn)
        first = next;
    } else {
        //前置結(jié)點(diǎn)的  尾結(jié)點(diǎn)指向被刪除的next結(jié)點(diǎn)；
        prev.next = next;
        //被刪除結(jié)點(diǎn)前指針置為null:
        x.prev = null;
    }
    //對(duì)尾結(jié)點(diǎn)同樣處理：
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
    x.item = null;
    size--;
    modCount++;
    return element;
}

//設(shè)置對(duì)應(yīng)角標(biāo)的元素：
public E set(int index, E element) {
    checkElementIndex(index);
    //通過node()方法，獲取到對(duì)應(yīng)角標(biāo)的元素：
    java.util.LinkedList.Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

//獲取對(duì)應(yīng)角標(biāo)所屬于的結(jié)點(diǎn)：
java.util.LinkedList.Node<E> node(int index) {
    //位運(yùn)算：如果位置索引小于列表長(zhǎng)度的一半，則從頭開始遍歷；否則，從后開始遍歷；
    if (index < (size >> 1)) {
        java.util.LinkedList.Node<E> x = first;
        //從頭結(jié)點(diǎn)開始遍歷：遍歷的長(zhǎng)度就是index的長(zhǎng)度，獲取對(duì)應(yīng)的index的元素
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        //從集合尾結(jié)點(diǎn)遍歷：
        java.util.LinkedList.Node<E> x = last;
        //同樣道理：
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

//獲取相應(yīng)角標(biāo)的元素：
public E get(int index) {
    //檢查角標(biāo)是否正確：
    checkElementIndex(index);
    //獲取角標(biāo)所屬結(jié)點(diǎn)的 元素值：
    return node(index).item;
}

List<String> linkedList = new LinkedList<String>();
Iterator<String> iterator =  linkedList.iterator();

public abstract class AbstractSequentialList<E> extends AbstractList<E> {
    public Iterator<E> iterator() {
        return listIterator();
    }
}

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {            
    public ListIterator<E> listIterator() {
        return listIterator(0);
    }
}

public ListIterator<E> listIterator(int index) {
    checkPositionIndex(index);
    return new ListItr(index);
}

private class ListItr implements ListIterator<E> {}