Java LinkedList ListIterator行为

我在java.util.LinkedList上使用java.util.ListIterator，希望它能像以下伪代码那样工作：

list = (1,2,3,4)
iterator.next should be 1
iterator.next should be 2
iterator.prev should be 1
iterator.next should be 2

但顺序是这样的：

iterator.next is 1
iterator.next is 2
iterator.prev is 2
iterator.next is 2

我不敢相信它是这样工作的，所以我创建了一个测试，但它会产生相同的输出。 所以我仔细研究了ListIterator的定义，当然是：

next()
Returns the next element in the list and advances the cursor position.
previous()
Returns the previous element in the list and moves the cursor position backwards.

因此，实现是正确的，但我仍然有一个问题：他们为什么选择这种行为？我得到它的方式不是更直观吗

以下是测试代码：

import static org.junit.Assert.assertEquals;
import org.junit.Before;
import org.junit.Test;
import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListTest {
    ListIterator<Integer> iterator;

    @Before
    public void setUp() throws Exception {
        LinkedList<Integer> list = new LinkedList<>();
        for (int i = 1; i < 5; i++) {
            list.add(i);
        }
        iterator = list.listIterator();
    }

    @Test
    public void successfullTest() throws Exception
    {
        assertEquals(1, (int) iterator.next());
        assertEquals(2, (int) iterator.next());
        assertEquals(2, (int) iterator.previous());
        assertEquals(2, (int) iterator.next());
        assertEquals(3, (int) iterator.next());
        assertEquals(4, (int) iterator.next());
    }

    @Test
    public void failingTest() throws Exception
    {
        assertEquals(1, (int) iterator.next());
        assertEquals(2, (int) iterator.next());
        assertEquals(1, (int) iterator.previous());
        assertEquals(2, (int) iterator.next());
        assertEquals(3, (int) iterator.next());
        assertEquals(4, (int) iterator.next());
    }
}

导入静态org.junit.Assert.assertEquals；
导入org.junit.Before；
导入org.junit.Test；
导入java.util.LinkedList；
导入java.util.ListIterator；
公共类LinkedListTest{
列表迭代器；
@以前
public void setUp（）引发异常{
LinkedList=新建LinkedList（）；
对于（int i=1；i<5；i++）{
列表.添加（i）；
}
迭代器=list.listIterator（）；
}
@试验
public void successfullTest（）引发异常
{
assertEquals（1，（int）迭代器.next（））；
assertEquals（2，（int）迭代器.next（））；
assertEquals（2，（int）迭代器.previous（））；
assertEquals（2，（int）迭代器.next（））；
assertEquals（3，（int）迭代器.next（））；
assertEquals（4，（int）迭代器.next（））；
}
@试验
public void failingTest（）引发异常
{
assertEquals（1，（int）迭代器.next（））；
assertEquals（2，（int）迭代器.next（））；
assertEquals（1，（int）迭代器.previous（））；
assertEquals（2，（int）迭代器.next（））；
assertEquals（3，（int）迭代器.next（））；
assertEquals（4，（int）迭代器.next（））；
}
}
中的迭代器从不指向特定元素，但在第一元素之前，在两个元素之间或刚好在最后元素之后的中间。
所以，当迭代器创建时，它看起来像

 1 2 3 4
^

调用
next
时，返回
1
，迭代器向前移动：

 1 2 3 4
  ^    

 1 2 3 4
    ^

再次调用
next
时，返回
2
，迭代器向前移动：

 1 2 3 4
  ^    

 1 2 3 4
    ^

调用
prev
时，返回
2
，迭代器向后移动：

 1 2 3 4
  ^    

因此对
next
的下一次调用将返回
2

请注意，无法获取迭代器的“当前”值。获取该值的唯一方法是移动迭代器

另一种实现C++中迭代器的方法。使用C++迭代器需要三个独立的操作：检索当前值，检查是否有移动值来检索和移动迭代器。而java方法只需要两个操作：检查是否有要检索的移动值、获取值和移动迭代器。因此，在java中实现自定义迭代器比C++更简单。
你能包括你运行的实际代码来得出这些结论吗？抱歉，在这里。当你第二次调用第二次（2）时，它将把光标移动到3，所以前面的将是2。似乎是合乎逻辑的。我认为它的定义是合乎逻辑的，但不是很直观。是吗？另一种选择是，下一步移动光标，然后获取元素，这意味着如果从列表的开始调用next，第一个元素将丢失。反之亦然。好的，这是一个很好的解释，它是如何，至少它使它更容易形象。但他们为什么这样做？只要它能更直观，为什么不这样做呢？增加了理由。