java迭代问题，二次迭代问题i

import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyArrrayList implements Iterable {
private static final int DEFAULT_CAPACITY = 10;
private int theSize;
private AnyType[] theItems;

public MyArrrayList() {
    clear();
}

public void clear() {
    theSize = 0;
    ensureCapality(DEFAULT_CAPACITY);
}

public int size() {
    return theSize;
}

public boolean isEmpty() {
    return size() == 0;
}

public void trimSize() {
    ensureCapality(size());
}

public AnyType get(int idx) {
    if (idx < 0 || idx >= size())
        throw new ArrayIndexOutOfBoundsException();
    return theItems[idx];
}

public AnyType set(int idx, AnyType newVal) {
    if (idx < 0 || idx >= size())
        throw new ArrayIndexOutOfBoundsException();
    AnyType old = theItems[idx];
    theItems[idx] = newVal;
    return old;
}

@SuppressWarnings("unchecked")
public void ensureCapality(int newCapality) {
    if (newCapality < theSize)
        return;
    AnyType[] old = theItems;
    theItems = (AnyType[]) new Object[newCapality];
    for (int i = 0; i < size(); i++) {
        theItems[i] = old[i];
    }
}

public boolean add(AnyType x) {
    add(size(), x);
    return true;
}

public void add(int idx, AnyType x) {
    if (theItems.length == size())
        ensureCapality(size() * 2 + 1);
    for (int i = theSize; i > idx; i--)
        theItems[i] = theItems[i - 1];
    theItems[idx] = x;
    theSize++;
}

public AnyType remove(int idx) {
    if (idx < 0 || idx >= size())
        throw new ArrayIndexOutOfBoundsException();
    AnyType removeItem = theItems[idx];
    for (int i = idx; i < theSize; i++)
        theItems[i] = theItems[i + 1];
    theSize--;
    return removeItem;
}

@Override
public Iterator<AnyType> iterator() {
    // TODO Auto-generated method stub
    return new ArrayListIterator(this);
}

private static class ArrayListIterator<AnyType> implements Iterator<AnyType> {
    private int current = 0;
    private MyArrrayList<AnyType> theList;
    public ArrayListIterator(MyArrrayList<AnyType> list){
        theList=list;
    }

    public boolean hasNext() {
        return current < theList.size();
    }

    public AnyType next() {

        return theList.theItems[current++];
    }

    public void remove() {
        theList.remove(--current);
    }
}

public static void main(String[] args) {
    MyArrrayList<Integer> list=new MyArrrayList<Integer>();
    for(int i=1;i<20;i++)
    list.add(i);

    Iterator<Integer> it=list.iterator();
    while(it.hasNext())
    {
        System.out.print(it.next());
        System.out.print(" ");

    }
    Iterator<Integer> its=list.iterator();


    while(it.hasNext())
    {
        System.out.println(it.next());
    }


}

}
请问我的输出为：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
明明写了两个输出语句，为什么只有一个输出呢？

Iterator its=list.iterator();

while(it.hasNext())
{
    System.out.println(it.next());
}

第二个你参数写错了 应该是its.hasNext()

hasnext 已经指向最后一个了下一个自然不满足条件

应该是hasnext的原因,你不能改成别的吗

三楼只正解。

第一个迭代器在第一个循环里面已经指向最后一个元素了。第二个循环还用第一个迭代器去取元素，当然就取不到了。应该用新的迭代器就可以。

先用it.hasNext() 判断集合里是不是已经没有元素了
如果有就用
it.next();
就是取得当前集合的元素 然后把指针往后移一位指向下一个元素(java确实还是有指针的只不过你不能自己调用罢了)
指针指完了就没有了，所以后面就进不去了，如果你还想打印可改为
it =list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}

先用it.hasNext() 判断集合里是不是已经没有元素了
如果有就用
it.next();
就是取得当前集合的元素 然后把指针往后移一位指向下一个元素(java确实还是有指针的只不过你不能自己调用罢了)
指针指完了就没有了，所以后面就进不去了，如果你还想打印可改为
it =list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}

it,its。没有区分，接着对it取hasnext肯定是假啊