标签: listiterator

我在执行此代码时收到ConcurrentModificationException.我无法弄清楚它为什么会发生？

private void verifyBookingIfAvailable(ArrayList<Integer> list, int id) {

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
                int value = iterator.next();
                if (value == id) {
                    int index = list.indexOf(id);

                    if (index != -1) {
                        list.remove(index);
                    }
                }
        }
    }

提前致谢.

我正在尝试使用列表迭代器从列表中删除对象.我已经浏览了网站上的其他解决方案,并没有减轻错误"线程中的异常"主"java.util.ConcurrentModificationException"

这是我的代码没有执行:

void PatronReturn(String bookName) {
//       get to beginning
    while(listIterator.hasPrevious()) {
        listIterator.previous();
    }
    while(listIterator.hasNext()){
        Book b = listIterator.next();
    if (listIterator.next().getBookTitle().equals(bookName)) { 
        //listIterator.next();
        //listIterator.remove();
        books.remove(b);
        //listIterator.next(); //moves to next so iterator can remove previous ?
        //books.remove(listIterator.next());; // TODO see if this is correct

    }
    }

这是关于迭代器如何在C++中的列表上工作的混淆.如果我错了,请纠正我.

引擎盖下的列表(在C++中)是双链表.我们知道双向链表的结构 - 数据区和指向下一个和前一个节点的指针.因此,双向链表中的每个节点都在内存中有一个地址.当我们在列表上声明一个迭代器时,它指向这个地址.因此,当我们解析迭代器时,我们如何只得到数据值呢？

我有一个函数，应该java.sql.Date根据设置为startDate- 的范围返回日期列表（）endDate。我先添加，startDate然后要增加它的值（+1天，一周或一个月），然后从“最新”日期一直走到到达endDate。

我尝试使用传统的foreach无效，因为它不允许在迭代时添加新日期，因此我切换到ListIterator。这只会进入while一次，增加日期，将其添加，但是显然没有，next因为该add函数不会在末尾附加项目（？）

解决该任务的实用方法是什么？

public List<Date> getBookingDatesInRange(Date startDate, Date endDate, boolean isDaily, boolean isWeekly) {

    List<Date> dates = new ArrayList<Date>();
    dates.add(startDate);
    ListIterator<Date> iter = dates.listIterator();         
    while(iter.hasNext()) {
        LocalDate new = iter.next().toLocalDate();
        Date newDate;
        if(isDaily) {
            newDate= Date.valueOf(new.plusDays(1));
        } else if(isWeekly) {
            newDate= Date.valueOf(new.plusWeeks(1));
        } else {
            newDate= Date.valueOf(new.plusMonths(1));
        }
        if(newDate.before(endDate) || newDate.equals(endDate) {
            iter.add(newDate);
        } else {
            return dates;
    }                   
}

我有以下代码:

LinkedList<String> list = new LinkedList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
ListIterator<String> iterator = list.listIterator();
String str = iterator.next();
System.out.println(str);
str = iterator.next();
System.out.println(str);
str = iterator.next();
System.out.println(str);
System.out.println("switch direction");
str = iterator.previous();
System.out.println(str);
str = iterator.previous();
System.out.println(str);

输出是这样的:

1
2
3
switch direction
3
2

我希望在第一次iterator.previous()调用时打印2,但不是.它给了我相同的元素,就像这个函数在第一次调用时什么都不做.

如果我从最后一次到第一次开始迭代,同样的事情发生,我将中间的方向改回到最后一次.

是否存在设计原因,或者它只是Java列表迭代器中的错误？

我在用:

java version "1.6.0_45"
Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)

我需要__iter__()为我的UnorderedList()课堂写一个方法的帮助。我尝试了这个：

def __iter__(self):
    current = self
    while current != None:
        yield current

但是while循环不会停止。这是我其余的课程和代码：

class Node:
    def __init__(self,initdata):
        self.data = initdata
        self.next = None

    def getData(self):
        return self.data

    def getNext(self):
        return self.next

    def setData(self,newdata):
        self.data = newdata

    def setNext(self,newnext):
        self.next = newnext

class UnorderedList:

    def __init__(self):
        self.head = None
        self.count = 0

我得到了一些C++代码,它具有以下结构的列表/迭代器.

typedef struct{
  int x;
  int y;
}my_struct;

std::list<my_struct> the_list;
std::list<my_struct>::iterator the_iter = the_list.begin();

然后代码以the_iter这种方式访问x和y :

(*the_iter).x;
(*the_iter).y;

我想将这些更改为更易读的版本:

the_iter->x;
the_iter->y;

从我的C角度来看,这对于指针解除引用来说完全没问题.迭代器也是如此吗？有没有理由说我的同事会用(*pointer).而不是p->

接口列表的迭代器方法是否可以返回null？

我注意到很多时候人们为list.iterator添加了空检查.我们真的需要这个检查.

Javadocs没有提到迭代器返回null,所以想确认一下.

链接:https://docs.oracle.com/javase/7/docs/api/java/util/List.html#iterator()

我正在使用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; …

我有一个简单LinkedList的Java,有10个元素.在那个州,我得到一个普通的ListIterator,说.listIterator(3).如果我然后插入/删除其他元素到列表中,而不触及我拥有的元素ListIterator(也不是迭代器),它ListIterator仍然有效吗？