将迭代器添加到我的数组列表

Question

import java.util.Iterator;

public class MyArrayList<E> implements Iterable<E> {
    public static final int DEFAULT_SIZE = 5;
    public static final int EXPANSION = 5;
    private int capacity;
    private int size;
    private Object[] items;

    public MyArrayList() {
        size = 0;
        capacity = DEFAULT_SIZE;
        items = new Object[DEFAULT_SIZE];
    }

    private void expand() {
        Object[] newItems = new Object[capacity + EXPANSION];
        for (int j = 0; j < size; j++) newItems[j] = items[j];
        items = newItems;
        capacity = capacity + EXPANSION;
    }

    public void add(Object obj) {
        if (size >= capacity) this.expand();
        items[size] = obj;
        size++;
    }

    public int size() {
        return size;
    }

    public Object get(int index) {
        try{
            return items[index];
            } catch(IndexOutOfBoundsException e){
                System.out.println("Exception Thrown: " + "Index is out of bound");
            }
            return index;
    }

    public boolean contains(Object obj) {
        for (int j = 0; j < size; j++) {
            if (obj.equals(this.get(j))) return true;
        }
        return false;
    }

    public void add(int index, Object obj) {
        try{
            if (size >= capacity) this.expand();
            for (int j = size; j > index; j--) items[j] = items[j - 1];
            items[index] = obj;
            size++;
              } catch(IndexOutOfBoundsException e){
                System.out.println("Exception Thrown: " + "Index is out of bound");
              }
            return;
    }

    public int indexOf(Object obj) {
        for (int j = 0; j < size; j++) {
            if (obj.equals(this.get(j))) return j;
        }
        return -1;
    }

    public boolean remove(Object obj) { 
        for (int j = 0; j < size; j++) {
            if (obj.equals(this.get(j))) {
                for (int k = j; k < size-1; k++) items[k] = items[k + 1];
                size--;
                items[size] = null;
                return true;
            }
        }
        return false;
    }

    public Object remove(int index) {
        try{
            Object result = this.get(index);
            for (int k = index; k < size-1; k++) items[k] = items[k + 1];
            items[size] = null;
            size--;
            return result;
             } catch(IndexOutOfBoundsException e){
                System.out.println("Exception Thrown: " + "Index is out of bound");
              }
            return index;
    }

    public void set(int index, Object obj) {
        try{
            items[index] = obj;
             } catch(IndexOutOfBoundsException e){
                System.out.println("Exception Thrown: " + "Index is out of bound");
             }
            return;
    }




public Iterator<E> iterator() {

    return new MyIterator<E>();
}

public class MyIterator <T> implements Iterator<T>{
    public boolean hasNext(){

    }

public T next(){

}

public void remove(){

    }
}


}

基本上我正在尝试改进我的数组列表的功能，因为它使用 for 循环来执行添加和删除等方法，但是我尝试使用迭代器，我搜索了它，我发现你不能只是只需在主类中添加可迭代的实现，它必须使用next()、hasNext() 和remove() 三个方法来实现。我在代码的底部添加了这三个方法，但我真的不确定如何实现它以使其开始工作。

Answer 1

您需要跟踪items 数组中Iterator 所在的索引。我们称之为int currentIndex。如果currentIndex < size，hasNext() 将返回true。如果hasNext() 是true，next() 将增加currentIndex 并返回items[currentIndex]，否则它应该抛出一个Exception，比如NoSuchElementException。删除将调用remove(currentIndex)。

Answer 2

这是一个例子（注意：我没有尝试编译这个或任何东西，所以如果你发现任何错误，请更新这篇文章！）

public class MyArrayList<E> implements Iterable<E> {
    ...

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private Object[] currentData = items;
            private int pos = 0;

            @Override
            public boolean hasNext() {
                return pos < currentData.length;
            }

            @Override
            public E next() {
                return (E) currentData[pos++];
            }

            @Override
            public void remove() {
                MyArrayList.this.remove(pos++);
            }
        };
    }
}

Answer 3

您需要将items 数组传递给您的MyIterator 类，以便您可以跟踪光标在数组中的当前位置。现在基于光标的当前位置，你可以实现所有的抽象方法。

在MyIterator 类的构造函数中，将数组作为参数传递为public MyIterator(E[] array)，并将数组存储为局部变量。同时创建一个局部变量 cursor 并将其值设置为 0。