标签: listiterator

我有一个std::list<some_object> events,我想删除该列表中除最后一个之外的所有元素.所以我想到了(正如这个帖子所建议的那样):

std::list<some_object>::iterator it = events.begin(); // Init iterator on top of list
while(it!=*std::advance(events.end(),-1)) events.erase(it++);

不幸的是,上面的代码不起作用,因为它会产生错误:

error: invalid initialization of non-const reference of type ‘std::_List_iterator<node_info>&’ from an rvalue of type ‘std::__cxx11::list<node_info>::iterator {aka std::_List_iterator<node_info>}’
             while(it!=*std::advance(event_heap.end(),-1)){

但是,是不是list::end应该返回迭代器？我究竟做错了什么？

我有大量的字符串列表,我希望iteratoe在这个列表上.我想弄清楚哪个是迭代列表的最佳方法.我尝试过使用以下方法:

• 发电机表达: g = (x for x in list)

• Itertools.chain: ch = itertools.chain(list)

对于列表迭代,是否有另一种方法,优于这两种方法？

我有一个作业问题，要求我制作一个从列表末尾开始的列表迭代器。我不知道该怎么做。这是代码

public class LinkedListTester7
{
    public static void main(String [] args)
    {
        LinkedList<Integer> list = new LinkedList<Integer>();
        for (int i = 0 ; i < 100 ; i = i + 2)
            list.add(i) ;
        //-----------Start below here. To do: approximate lines of code = 3
        // 1. make a list iterator that starts at the end of the list ;
        ListIterator<Integer> litr = list.listIterator();
        //2.  while hasPrevious ;
        while (litr.hasPrevious()) {
            //3. print what is returned by previous() followed by …

我有一个HashMap声明为

static HashMap<String,ArrayList<Integer>> inverted_index = new HashMap<String,ArrayList<Integer>>();

我重复了它的键

    public static void printInvertedIndex() throws FileNotFoundException{
    PrintWriter writer = new PrintWriter(new File("InvertedIndex.txt"));
    Iterator it = inverted_index.entrySet().iterator();

    while (it.hasNext()) {
        Map.Entry pair = (Map.Entry)it.next();
        writer.println(pair.getKey() + "  " + pair.getValue());
        it.remove();
        }

    writer.close();
}

我在一个名为printInvertedIndex()的函数中完成了所有这些操作.现在在其他一些函数中我想再次迭代HashMap,所以我做了这个

    public static void createPermutermIndex(){
    permuterm_index.clear();

    Iterator it = inverted_index.entrySet().iterator();

    while (it.hasNext()) {
        System.out.println("here");
        Map.Entry pair = (Map.Entry)it.next();
        String temp;
        temp = pair.getKey() + "$";
        ArrayList<String> perms = rotations(temp);
        System.out.println(perms.size());
        for(int i=0; i<perms.size(); i++)
            System.out.println(perms.get(i));
            //permuterm_index.put(temp, perms.get(i));
        it.remove();
        } …

编辑：在您的帮助下，我设法解决了我的问题。我已经编辑了我的代码，现在显示我必须如何设置它才能使其正常工作。

目前我在编写比较两个迭代器内容的部分时遇到问题。作为我的作业要求的一部分，我需要使用链表来存储输入字符串的各个字符。我已经到了我有两个迭代器的地步，它们将包含一种方式和相反方式的输入。

        String palindrom = input.getText();
        String [] chara = palindrom.split (""); //this is successfully splitting them, tested.


        int length = palindrom.length( ); // length == 8
        System.out.println (length); //can use this for how many checks to do?
        LinkedList ll = new LinkedList(Arrays.asList(chara));


        Iterator iterator = ll.iterator();
        Iterator desIterator = ll.descendingIterator();

        /*while(iterator.hasNext() ){
            System.out.println(iterator.next() );
        }

        while(desIterator.hasNext() ){
            System.out.println(desIterator.next() );
        }*/
        boolean same = true;
        while(iterator.hasNext()){
            if(!iterator.next().equals(desIterator.next())){
            same = false;
            break;
          }
        }

使用 System.out 我可以看到它们被正确存储，但我不知道如何检查迭代器是否存储相同的内容。比较两个迭代器或将它们转换为我可以比较的东西的最简单方法之一是什么？为了澄清我想验证它们以相同的顺序包含相同的元素。

我试图从列表中删除对象,我得到以下异常:

failure:java.util.ConcurrentModificationException null

这就是我尝试从列表中删除对象的方法:

private List<testVO> removeDuplicateEntries(List<testVO> sessionList,List<testVO> dbList){


        for (Iterator<testVO> dbIterator = dbList.listIterator(); dbIterator.hasNext(); ) {
            testVO voDB = dbIterator.next();

            for (Iterator<testVO> sessionIterator = sessionList.iterator(); sessionIterator.hasNext();) {
                testVO voSession = (testVO) sessionIterator.next();

                if(voDB.getQuestionID().intValue() == voSession.getQuestionID().intValue()){
                    //remove the object from sesion list
                    sessionIterator.remove();
                    //Add the object from DB to session list
                    sessionList.add(voDB);
                }

            }

        }

        return sessionList;
    }

我想删除当前的副本sessionList并添加来自的重复项dbList.

我正在学习迭代器以及如何使用它们，并在此过程中提出了一个问题。是否有可能在迭代过程中回忆循环停止的位置（如果循环有一个中断条件得到满足），然后从召回的位置开始？

我所说的一个例子是，我有这个代码：

print("Range() Test")
for i in range(10, 100, 10):
    if i == 60:
        print('Break Point')
        break
    print(i)
for i in range(10, 100, 10):
    print(i)

哪个应该运行并给你这样的东西：

Range() Test
10
20
30
40
50
Break Point
10
20
30
40
50
60
70
80
90

我的第一个问题是：

1）有没有办法回忆起休息发生的位置并从那里开始，而不是我笨拙的重新开始？我已经看到实例化，其中迭代在项目列表上，但无法找到一个示例/找出在开始/停止/步骤符号上使用 iter() 的功能示例。

2）在做研究（我正在学习 Python 并做了很多自学）我已经看到 range() 函数描述器既是迭代器又不是迭代器，所以，如果有人对此有更明确的信息，而不是为了在我的示例中使用它而撕裂我一个新的，这将不胜感激。

谢谢！

我有一个TreeVertex类:

// TreeVertex.h
#ifndef __TREEVERTEX__
#define __TREEVERTEX__

#include <list>

using namespace std;

class TreeVertex {
public:
    TreeVertex(list<int>, TreeVertex* = NULL);
    list<int> getItemset();
private:
    list<int> Itemset;

    TreeVertex * Parent;
    TreeVertex * LeftChild;
    TreeVertex * RightSibling;
};

#endif // __TREEVERTEX__

// TreeVertex.cpp

#include "TreeVertex.h"

TreeVertex::TreeVertex(list<int> Itemset, TreeVertex* Parent) : Itemset(Itemset),     Parent(Parent), LeftChild(NULL),
    RightSibling(NULL) { }

list<int>
TreeVertex::getItemset() {
    return Itemset;
}

和这样的主要功能:

#include <iostream>
#include "TreeVertex.h"

using namespace std;

int main (int argc, const char ** const argv)
{    
    list<int> tmpList1;
    tmpList1.push_back(1); …

我正在使用ArrayList的iterator:

List<String> al = new ArrayList<>();
// ----- Logic for adding elements-----
Iterator it = al.iterator();
// logic to retrieve elements----

然后它尝试使用ListIterator,就像这样.

ListIterator li = al.listIterator();
    while(li.hasNext()) {
        System.out.print(li.next()+" ");
    }

有效 ...

我试着这个用于反向检索

ListIterator li = al.listIterator();
while(li.hasPrevious()) {
        System.out.print(li.previous()+" ");
    }

但它不起作用.

以下代码正常运行.

ListIterator<String> li = al.listIterator(al.size());
    while(li.hasPrevious()) {
        System.out.println(li.previous()+" ");
    }

我想知道有一些泛型的概念,但不清楚它.请清除Iterator和ListIterator的概念.为什么ListIterator的一个语句正在运行另一个而不是？

我使用 ListIterator 在列表中进行迭代，因为如果满足某些条件，我想在运行时添加一些元素。

但是添加到列表中的新元素永远不会包含在迭代器中

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Example {
    public static void main(String[] s)
    {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(5);
        list.add(6);

        ListIterator<Integer> listIterator = list.listIterator();
        while(listIterator.hasNext())
        {
            int i = listIterator.next();
            System.out.println("List Element: " + i + " | List size: " + list.size());
            if(i==1)
            {
                //Adding '3' to list
                listIterator.add(3);
                System.out.println("Added Element: 3");
            }
            if(i==2)
            {
                //Adding '4' to list
                listIterator.add(4);
                System.out.println("Added Element: 4");
            }
        }
    }
}

下面是输出

List Element: …

我想得到::iterator最后一个元素list.

我的理解是你可以把迭代器带到.front()列表中.begin(),但是.back()呢？由于列表边界不包含最终元素,.end()因此迭代器将超过back()列表元素.

我尝试使用.rbegin(),逻辑上似乎正是我想要的,但它似乎返回一个reverse_iterator类型,这导致我的代码不匹配的类型.

我有以下代码抛出ConcurrentModificationException,因为我在同一个列表中使用两个不同的迭代器,其中一个正在修改列表.因此,第二个迭代器在读取列表时抛出异常,因为其他迭代器已经修改了列表.

    List<Integer> list = new ArrayList<>();

    populate(list);//A method that adds integers to list

    ListIterator<Integer> iterator1 = list.listIterator();
    ListIterator<Integer> iterator2 = list.listIterator();

    while (iterator1.hasNext()) {
        if(iterator1.next() < 5)
            iterator1.remove();
    }

    while (iterator2.hasNext()){
        if(iterator2.next() < 5) {
         //Call handler   
        }
    }

我的问题是,如果它还没有到达一个尚未被删除的元素,那么内部如何iterator2知道has已被其他迭代器修改过？怎么弄清楚其他一些人已经改变了？一种方法可能是跟踪大小,但这不是原因,因为其他迭代器可以只替换任何元素.listiterator1iteratorlist

我有以下代码:

    ArrayList<String> words;
    words = new ArrayList<String>();
    words.add("is");
    words.add("us");
    ListIterator<String> it;
    it = words.listIterator();
    it.add("##");
    System.out.println(words);
    it.next();
    it.next();
    it.previous();
    it.set("##");
    System.out.println(words);

我希望输出会是## us ##,但是当我运行程序时它会返回## is ##.我希望这与ListIterator添加项目ArrayList而不是ArrayList向其自己添加项目有关.

为什么程序以这种方式运行？