如何在Java中将迭代器实现为类的属性

Question

假设我有这个简单的MyArray类,有两个简单的方法:add,delete和iterator.在main方法中,我们可以看到它应该如何使用:

public class MyArray {
int start;
int end;
int[] arr;
myIterator it;
public MyArray(){
    this.start=0;
    this.end=0;
    this.arr=new int[500];
    it=new myIterator();
}
public void add(int el){
    this.arr[this.end]=el;
    this.end++;
}
public void delete(){
    this.arr[this.start]=0;
    this.start++;
}

public static void main(String[] args){
    MyArray m=new MyArray();

    m.add(3);
    m.add(299);
    m.add(19);
    m.add(27);
    while(m.it.hasNext()){
        System.out.println(m.it.next());
    }
}

然后MyIterator应该以某种方式实现:

import java.util.Iterator;

public class myIterator implements Iterator{

@Override
public boolean hasNext() {
    // TODO Auto-generated method stub
    return false;
}

@Override
public Object next() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public void remove() {
    // TODO Auto-generated method stub

}

}

MyIterator应该从MyArray类迭代arr,从开始到结束值; 两者都是MyArray的属性.因此,由于MyIterator应该使用MyArray属性,MyIterator应该如何实现？也许我可以在初始化中发送当前对象:

it=new myIterator(this);

但我想这不是最好的灵魂.或者也许MyArray本身应该实现Iterator接口？这是怎么解决的？

编辑:

好的,谢谢大家.这是我想要做的一个简单的例子,因此不关心固定长度数组.啥子我真正想要做的是一个循环的FIFO,这就是为什么start和end是光标.

该循环FIFO将是一对整数对的数组,例如,大小为300 : int[][] arr=new int[300][2].

当迭代一个循环数组时,我必须小心,如果计数器到达终点并使其从头开始,所以这就是我解决它的方法:

if  (this.start >= this.end )   temp_end=this.end+this.buff.length; 
else    temp_end=this.end;
int ii;
int j=0;
int[] value=new int[2];
for(int i=this.start; i<temp_end; i++){
    ii=i% this.arr.length;
    value=this.buff[ii]; 
    //do anything with value

}

但我想避免担心这些事情并且只是以一种简单的方式迭代,我可以用迭代器接口做到这一点,但后来我遇到了两个问题:我已经解释过的第一个问题已被许多答案解决了,第二个一个是我的数组由一对int组成,我不能使用原始类型的迭代器.

Answer 1

将迭代器维护为类的实例变量非常不寻常.您只能遍历数组一次 - 可能不是您想要的.更有可能的是,您希望您的类为想要遍历数组的任何人提供迭代器.下面是一个更传统的迭代器.

Java 5+代码 - 我没有尝试编译或运行,因此它可能包含错误(现在不在dev机器附近).它还使用autobox'ing转换Integer为int.

public class MyArray implements Iterable<Integer> {

    public static class MyIterator implements Iterator<Integer> {

        private final MyArray myArray;
        private int current;

        MyIterator(MyArray myArray) {
            this.myArray = myArray;
            this.current = myArray.start;
        }

        @Override
        public boolean hasNext() {
            return current < myArray.end;
        }

        @Override
        public Integer next() {
            if (! hasNext())   throw new NoSuchElementException();
            return myArray.arr[current++];
        }

        @Override
        public void remove() {
            // Choose exception or implementation: 
            throw new OperationNotSupportedException();
            // or
            //// if (! hasNext())   throw new NoSuchElementException();
            //// if (currrent + 1 < myArray.end) {
            ////     System.arraycopy(myArray.arr, current+1, myArray.arr, current, myArray.end - current-1);
            //// }
            //// myArray.end--;
        }
    }

    ....

    // Most of the rest of MyArray is the same except adding a new iterator method ....

    public Iterator<Integer> iterator() {
        return new MyIterator();
    }

    // The rest of MyArray is the same ....

}

另请注意:请注意不要在静态阵列上达到500元素限制.如果可以,请考虑使用ArrayList类.