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(){

    }
}


}

基本上我试图改进我的arraylist的功能，因为它使用for循环来添加和删除等方法，但是我试图使用迭代器而我搜索了它，我发现了你不能简单地将实现迭代添加到主类，它必须通过使用三个方法next（），hasNext（）和remove（）来实现。我在代码的底部添加了三种方法，但我真的不确定如何实现它以使其开始工作。

Answer 1

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

Answer 2

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

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

Answer 3

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

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++);
            }
        };
    }
}

在我的arraylist中添加一个迭代器

3 个答案: