标签: iterator

在HashMap中

map = new HashMap<String,String>();

it = map.entrySet().iterator();
while (it.hasNext())
{
    entry = it.next();
    it.remove(); //safely remove a entry
    entry.setValue("new value"); //safely update current value
    //how to put new entry set inside this map
    //map.put(s1,s2); it throws a concurrent access exception

}

当我试图添加一个新的条目来映射它抛出ConcurrentModificationException.对于删除和更新,迭代器已安全地删除方法.如何在迭代时添加新条目？

我找不到任何关于此的话题.我想知道在循环期间更改列表类的引用是否安全,如下所示:

Tree minimalTree = someTree;
for (Tree st : minimalTree.getSubtrees()) {
  if (condition)
    minimalTree = st;
}

迭代器是否会重置并重新启动以获取新引用？

编辑:我忘了说:这段代码适用于我想缩小搜索树中元素的情况,比方说,包含某些元素的小树.在这种情况下,继续只查看"minimalTree"的内部结构而不是整个"someTree"结构会更快.

假设我们有一些existingIterator迭代任意类型的元素T.我现在想要实现的是从existingIterator修改后的行为派生出一个新的迭代器.想想以下例子:

• 限制原始迭代器的长度,例如existingIterator.take(n).
• 映射元素,例如, existingIterator.map(modifier)
• 过滤某些元素,例如existingIterator.filter(predicate).

在所有这些情况下,我只想生成另一个迭代器,以便我可以做类似的事情:

for x in existingIterator.filter(something)
                         .map(modifier)
                         .take(10):
  ...

我的一般问题是:如何编写一个通用的迭代器或模板,它接受一个现有的迭代器并返回一个修改过的迭代器？

后续问题将是为什么这些基本功能不在标准库中 - 也许我错过了什么？

这是我尝试过的:

尝试1

我们以take(n)功能为例.我的第一种方法是使用常规通用iterator:

iterator infinite(): int {.closure.} =
  var i = 0
  while true:
    yield i
    inc i

iterator take[T](it: iterator (): T, numToTake: int): T {.closure.} =
  var i = 0
  for x in it():
    if i < numToTake:
      yield x
    inc i

for x in infinite.take(10):
  echo …

我似乎无法创建一个生成器方法作为对象文字.

这是我的工作源代码:

function *getRecords (data) {
    for (var i = 0; i < data.length; i++) {
        yield data[i];
    }
}
var records = getRecords(data);
for (var record of records) {
   // process my record
}

但是当我在对象文字中移动我的生成器方法时:

var myobj = {
    *getRecords: function (data) {...}
}

我明白了 SyntaxError: Unexpected token *

如果我添加引号

var myobj = {
    '*getRecords': function (data) {...}
}

我明白了: SyntaxError: Unexpected strict mode reserved word

我用--harmony选项运行nodejs v0.12.2 ,但不管我做什么,我似乎无法让它工作.

根据en.cppreference.com和VC++ 14.0,迭代器需要具有复制构造函数和复制赋值运算符.

我的迭代器类(它通过Windows进程迭代)不能是可复制构造或可复制 - 它拥有一个HANDLE快照并管理释放它所以不可能复制那些 - 移动它们是可能的,我提供了一个移动构造函数和移动赋值运算符.但是,算法会std::find_if复制它们(在VC++ 14.0中是一些std::_Find_if需要复制迭代器的调用)并且不想工作.

为什么你的迭代器会占用资源？迭代器应该像指针指向某个东西.

因为为了遍历Windows进程,您需要创建一个快照,然后使用它来执行此操作 - 问题是,一个快照,一个迭代.快照也不可复制.

为什么他们不能MoveConstructible和MoveAssignable？哪些算法(如果有的话)真的需要复制迭代器才能工作？

Qt 5.0引入了迭代器方法,cbegin()并引入了cend()不同的容器类,如QList或QMap.

但是这些课程中也有方法constBegin()和constEnd()方法.

所有这些方法都是constSTL风格的const_iterator.

• 难道cbegin()/ cend()比相同的功能constBegin()/ constEnd()？对我来说似乎是这样,但在QList,QMap或容器类的文档中没有说明任何内容.
• 是否有人应该使用cbegin()/ cend()而不是constBegin()/ constEnd()反之亦然？

我是Java Collections的新手,我怀疑为什么我不能在向后的方向上遍历链表中的元素.我将解释我做了什么,请澄清我的怀疑.

1. 我为前向迭代创建了接口迭代器,为后向迭代创建了listiterator.为什么反向迭代不起作用？

2. 我不能在同一个程序中使用iterator和listiterator接口来遍历前向和后向迭代中的一组元素吗？

   代码片段:

   import java.util.*;
   class NewClass{
   public static void main(String args[]){
     LinkedList<String> obj = new LinkedList<String>();
   
      obj.add("vino");
      obj.add("ajith");
      obj.add("praveen");
      obj.add("naveen");
   
      System.out.println(obj);
   
      System.out.println("For loop ");
      //using for loop
      for(int count=0; count < obj.size(); count++){
        System.out.println(obj.get(count));
      }
     System.out.println("For each loop ");
   
     //using foreach loop
     for(String s:obj){
        System.out.println(s);
     }
     System.out.println("Whileloop ");
   
     //using whileloop
     int count=0;
     while(obj.size() > count){
         System.out.println(obj.get(count));
       count++;
     }
     System.out.println("Forward Iterations ");
     //using iterator 
     Iterator it = obj.iterator();
     while(it.hasNext()){
        System.out.println(it.next()); …

   Run Code Online (Sandbox Code Playgroud)

我有一个Python程序,它使用Pytables并以这种简单的方式查询表:

def get_element(table, somevar):
    rows = table.where("colname == somevar")
    row = next(rows, None)
    if row:
        return elem_from_row(row)

为了减少查询时间,我决定尝试对表进行排序table.copy(sortby='colname').这确实改善了查询时间(花费where),但它将next()内置函数花费的时间增加了几个数量级!可能是什么原因？

仅当表中有另一列时,才会发生此减速,并且减速随着该列的元素大小而增加.

为了帮助我理解这个问题,并确保这与我的程序中的其他内容无关,我做了这个最小的工作示例来重现问题:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tables
import time
import sys


def create_set(sort, withdata):
    #Table description with or without data
    tabledesc = {
        'id': tables.UIntCol()
    }
    if withdata:
        tabledesc['data'] = tables.Float32Col(2000)

    #Create table with CSI'ed id
    fp = tables.open_file('tmp.h5', mode='w')
    table = fp.create_table('/', 'myset', tabledesc)
    table.cols.id.create_csindex()

    #Fill the table with …

为什么java.util.Iterator界面有方法remove()？

当然,有时候这种方法是必要的,所有人都习惯了它的存在.但实际上迭代器的主要和唯一目的只是提供访问容器元素.当有人想为这个界面创建自己的实现,并且不能或不想以任何理由提供删除元素的能力时,他就被迫抛出UnsupportedOperationException.扔掉那个异常通常表明一个没有深思熟虑的架构或设计中的一些缺陷.

我真的不明白这样决定的原因.我想这将更正确地分离特定的子接口以支持可选方法:

任何合理的版本为什么remove()是一部分Iterator？这个直接违反单一责任原则的例子不是SOLID吗？

我有以下地图: Map<Integer,String[]> map = new HashMap<Integer,String[]>();

键是整数,值是数组(也可以用列表替换).

现在,我想获得键之间所有可能的值组合.例如,假设地图包含以下条目:

key 1: "test1", "stackoverflow"
key 2: "test2", "wow"
key 3: "new"

组合包括

("test1","test2","new")
("test1","wow","new")
("stackoverflow", "test2", "new")
("stackoverflow", "wow", "new")

为此,我想象一个方法boolean hasNext(),如果有下一对,则返回true,第二个方法只返回下一组值(如果有的话).

如何才能做到这一点？地图也可以由其他数据结构替换.