假设我有一个列表,其中没有添加或删除新节点.但是,节点可能会被混乱.
保存迭代器,指向列表中的节点并在以后任意时间访问它是否安全？
编辑(后续问题):list :: splice()的文档说它从参数列表中删除了元素.这是否意味着如果我使用与函数的参数相同的列表调用splice,现有的迭代器将被无效？
我之前正在重构一些代码,我遇到了一个迭代器块的实现,我不太确定.在客户端为某些数据调用extrernal API的系统的集成层中,我有一组转换器,它们从API返回的数据并将其转换为逻辑层中使用的业务实体的集合.常见的翻译类将如下所示:
// translate a collection of entities coming back from an extrernal source into business entities
public static IEnumerable<MyBusinessEnt> Translate(IEnumerable<My3rdPartyEnt> ents) {
// for each 3rd party ent, create business ent and return collection
return from ent in ents
select new MyBusinessEnt {
Id = ent.Id,
Code = ent.Code
};
}
今天我遇到了以下代码.同样,它是一个翻译类,它的目的是将参数中的集合转换为方法返回类型.但是,这次它是一个迭代器块:
// same implementation of a translator but as an iterator block
public static IEnumerable<MyBusinessEnt> Translate(IEnumerable<My3rdPartyEnt> ents) {
foreach(var ent in ents)
{
yield return new MyBusinessEnt { …我正在运行以下代码:
val it = List(1,1,1,2,2,3,3).iterator.buffered
val compare = it.head
it.takeWhile(_ == compare).toList
它返回(1,1,1).但是,如果我这样运行:
val it = List(1,1,1,2,2,3,3).iterator.buffered
it.takeWhile(_ == it.head).toList
我得到(1,1).为什么会这样？是否head在通话时评估,takeWhile结果应该相同？
当我运行以下代码时,我得到一个例外.我搜索但找不到任何解决方案.
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.HashMap$HashIterator.nextEntry(Unknown Source)
at java.util.HashMap$KeyIterator.next(Unknown Source)
at com.aybits.software.linkgrabber.Grabber.main(Grabber.java:45)
第45行用于(String linkFromCollection:linksList){
public class Grabber {
static String url;
Document doc;
static Set<String> linksList = new HashSet<String>();
String matchingString ="java2s.com/Code";
static boolean isCrawling = true;
static int STOP_WATCH = 0;
public Grabber(String url){
Grabber.url = url;
}
public void grabLinks(String urlToCrawl) throws IOException{
doc = Jsoup.connect(urlToCrawl).timeout(20 * 1000).get();
Elements links = doc.select("a[href]");
for (Element link : links) {
//print(" * a: <%s> (%s)", link.attr("abs:href"), trim(link.text(), …我有一个"列"容器类型:
struct MyColumnType {
// Data: Each row represents a member of an object.
vector<double> a; // All vectors are guaranteed to have always
vector<string> b; // the same length.
vector<int> c;
void copy(int from_pos, int to_pos); // The column type provides an interface
void swap(int pos_a, int pos_b); // for copying, swapping, ...
void push_back(); // And for resizing the container.
void pop_back();
void insert(int pos);
void remove(int pos);
// The interface can be extended/modified if required
};
用法: …
我知道如果使用迭代器在某个线程遍历它时将更改Collection,则iterator.next()将抛出ConcurrentModificationException.
但它根据列表中的元素数量显示不同的行为.
我尝试了一个代码片段,在其中遍历for-each循环中的列表,在它之间,遍历使用列表的remove()方法从列表中删除了一个元素.
理想情况下,它应该在此条件下抛出ConcurrentModificationException而不依赖于列表中的元素数量,但是当列表中的元素数量为2时,它不是真的.
案例1: 列表中的元素数量 - 1
public static void main(String[] args)
{
List<String> list=new ArrayList<String>();
list.add("One");
for (String string : list)
{
System.out.println(string);
list.remove(string);
}
}
输出:一
线程"main"java.util.ConcurrentModificationException中的异常
这是预期的.
案例2:列表中的元素数量 - 2
public static void main(String[] args)
{
List<String> list=new ArrayList<String>();
list.add("One");
list.add("two");
for (String string : list)
{
System.out.println(string);
list.remove(string);
}
}
输出:一
没有例外被抛出?????????
案例3:列表中的元素数量 - 3
public static void main(String[] args)
{
List<String> list=new ArrayList<String>();
list.add("One");
list.add("Two");
list.add("Three");
for (String string …给定一个结构集合,如何使用"范围"模板迭代器打印出一个表,该表为每个结构分配一行,每个字段的列没有明确命名字段？
container := []Node
type Node struct {
Contact_id int
Employer_id int
First_name string
Middle_name string
Last_name string
}
模板代码:
{{range .container}}
<tr>
<td>{{.Prefix}}</td>
<td>{{.First_name}}</td>
<td>{{.Middle_name}}</td>
<td>{{.Last_name}}</td>
<td>{{.Contact_id}}</td>
<td>{{.Employer_id}}</td>
</tr>
{{end}}
当我尝试使用迭代值时
{{range .container}}
{{range .}}
<td>{{.}}</td>
{{end}}
{{end}}
有人告诉我,我无法迭代价值观.有没有干净的方法来做到这一点？
我正在display()为容器类型创建一个方便的函数模板.最后一个元素的输出与其余元素不同,因此我检查何时myIterator != --cont.cend();.这适用于std::vector,但不适用std::array.为什么？
这是一个MWE(不是我的实际代码):
std::vector<double> vec({1,2});
std::array<double, 2> arr({{1,2}});
auto vecIt = --vec.end(); // OK
auto arrIt = --arr.end(); // error: lvalue required as decrement operand
我目前正在研究python中的迭代.
我遇到了以下代码.
def myzip(*args):
iters = map(iter, args)
while iters:
res = [next(i) for i in iters]
print(res)
yield tuple(res)
list(myzip('abc', '1mnop'))
当我在3.X中运行代码时,代码会进入无限循环并打印
['a', '1']
[]
[]
[]
...
我从作者那里得到的解释是
3.X map返回一次性可迭代对象而不是2.X中的列表.在3.X中,只要我们在循环中运行一次列表理解,它就会耗尽,但仍然是真的(并且res将永远是[]).
但我仍在努力了解正在发生的事情及其发生的原因.
而且,为什么变量res仅('a', 'l')在while循环的第一次迭代中赋值？为什么没有分配('b', 'm'),然后('c', 'n')在第二次和第三次迭代？
我有一个简单的问题：在Lippman第10章的C ++入门5中。它说：“迭代器类别”：
迭代器类别
输入迭代器：可以读取序列中的元素。输入迭代器必须提供
相等和不相等运算符（
==，!=）比较两个迭代器前缀和后缀增量（
++）推进迭代器解引用运算符（
*）以读取元素；取消引用可能仅出现在作业的右侧箭头运算符（
->）是—的同义词，(*it).member即取消引用迭代器并从基础对象中获取成员。
他的意思是“去引用运算符（*）以读取元素；去引用只能出现在作业的右侧”：在“作业的左侧”。
我对此感到困惑。谢谢。