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

Question

假设我有这个简单的MyArray类，它有两个简单的方法：添加，删除和迭代器。在主要方法中，我们可以看到应该如何使用它：

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+代码-我没有尝试编译或运行，因此可能包含错误（当前不在开发机器附近）。它还使用自动装箱转换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类。