Java 如何从另一个类访问ListIterator.previous（）

我在“统计”类中进行了以下迭代

在我的“history”类中，我有一个ListIterator（而不是一个迭代器，因为我也想向后走）

@覆盖
公共列表迭代器迭代器（）{
//System.out.println（“在迭代器中”）；
ListIterator it=新ListIterator（）{
私有int currentIndex=0；
@凌驾
公共布尔hasNext（）{
返回currentIndex0；
}
@凌驾
公众号码下一个（）{
返回spins.get（currentIndex++）；
}
@凌驾
公众号码前（）{
if（hasPrevious（））{
返回spins.get（currentIndex-1）；
}
返回null；
}
@凌驾
public int previousIndex（）{
返回电流指数-1；
}
@凌驾
公共int nextIndex（）{
返回电流指数+1；
}
//由于此应用程序不需要以下函数，因此未实现这些函数
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（）；
}
@凌驾
公共无效集（编号n）{
抛出新的UnsupportedOperationException（）；
}
@凌驾
公共无效添加（编号n）{
抛出新的UnsupportedOperationException（）；
}
};
归还它；
}

。。。但是，当我迭代统计类中的数字时，我不知道如何得到前面的元素

本质上，我希望遍历数字，但偶尔会得到上一个数字（在经过它之后）

当然，我可以存储它，但似乎我应该能够调用ListIterator.previous（），但我不确定如何做到这一点

有什么想法吗

---

G

您不能使用

foreach

循环。您需要显式地使用迭代器，然后可以调用它的

previous（）

方法

比如说

for (ListIterator<Number> itr = history.iterator() ; itr.hasNext() ; ) {
    itr.previous();
}

for（ListIterator itr=history.iterator（）；itr.hasNext（）；）{
itr.previous（）；
}

或者使用一个while循环，这样看起来就不那么混乱了

ListIterator<Number> itr = history.iterator();
while(itr.hasNext()) {
    itr.previous();
}

ListIterator itr=history.iterator（）；
while（itr.hasNext（））{
itr.previous（）；
}

实际上，Kayaman已经以两种不同的方式明确地使用了

迭代器解决了您的问题

我只是根据您的要求编写了一个简单的演示：

public class HelloWorld {
public static void main(String... args) {
    int size = 5;
    History<Integer> history = new HelloWorld().new History<>(size);
    for (int i = 0; i < size; ++i) {
        history.add(Integer.valueOf(i));
    }

    for (Integer a : history) {
        System.out.println(a);
        if (a % 3 == 1) {
            System.out.println(history.iterator().previous());
        }
    }
}

class History<T> implements Iterable<T> {
    T[] arr;
    int index;

    public History(int theSize) {
        index = -1;
        arr = (T[]) new Object[theSize];
    }

    public void add(T t) {
        arr[++index] = t;
    }

    @Override
    public ListIterator iterator() {
        return new ListIterator() {
            int i = 0;
            @Override
            public boolean hasNext() {
                return i <= index;
            }

            @Override
            public Object next() {
                return arr[i++];
            }

            @Override
            public boolean hasPrevious() {
                return i > 0;
            }

            @Override
            public Object previous() {
                return arr[i - 1];
            }

            @Override
            public int nextIndex() {
                return 0;
            }

            @Override
            public int previousIndex() {
                return 0;
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }

            @Override
            public void set(Object o) {
                throw new UnsupportedOperationException();
            }

            @Override
            public void add(Object o) {
                throw new UnsupportedOperationException();
            }
         };
      }
   }
}

显然，for循环的
实际上正在使用

while(history.hasNext()) {
     history.next();
}

要迭代
历史记录
。因此，如果直接在
for循环
中使用
history.iterator（）.previous（）
，实际上是在创建一个新的
迭代器
，该迭代器将从本例的
0
开始

你不想要它，对吗

明确使用
迭代器将适合您的情况，如下所示：

    ListIterator<Integer> iterator = history.iterator();
    while(iterator.hasNext()) {
        int a = iterator.next();
        System.out.println(a);
        if (a % 3 == 1) {
            System.out.println(iterator.previous());
        }

    }

ListIterator iterator=history.iterator（）；
while（iterator.hasNext（））{
int a=迭代器.next（）；
系统输出打印项次（a）；
如果（a%3==1）{
System.out.println（迭代器.previous（））；
}
}
什么是旋转？在哪里初始化和赋值？不能使用
foreach
循环。您需要显式地使用迭代器，然后可以调用它的
previous（）
method.Doh！！是的，需要更多的咖啡因。@Graham如果它解决了你的问题，你应该把它标记为一个答案，供其他人参考。如果是好的，你应该投支持票。
  43: invokevirtual #9                  // Method com/company/HelloWorld$History.iterator:()Ljava/util/ListIterator;
  46: astore_2
  47: aload_2
  48: invokeinterface #10,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
  53: ifeq          101
  56: aload_2
  57: invokeinterface #11,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
  62: checkcast     #12                 // class java/lang/Integer
  65: astore_3
  66: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
  69: aload_3
  70: invokevirtual #14                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
  73: aload_3
  74: invokevirtual #15                 // Method java/lang/Integer.intValue:()I
  77: iconst_3
  78: irem
  79: iconst_1
  80: if_icmpne     98
  83: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
  86: aload_1
  87: invokevirtual #9                  // Method com/company/HelloWorld$History.iterator:()Ljava/util/ListIterator;
  90: invokeinterface #16,  1           // InterfaceMethod java/util/ListIterator.previous:()Ljava/lang/Object;
  95: invokevirtual #14                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V

while(history.hasNext()) {
     history.next();
}

    ListIterator<Integer> iterator = history.iterator();
    while(iterator.hasNext()) {
        int a = iterator.next();
        System.out.println(a);
        if (a % 3 == 1) {
            System.out.println(iterator.previous());
        }

    }